哥德巴赫猜想 请编写程序，读入2个整数m和n，然后输出m到n之间所有偶数的一组分解结果。

哥德巴赫猜想是一个未解决的数学猜想，它表明任何大于2的大偶数都可以表示为两个素数之和。虽然这个猜想尚未得到证明，但在实践中已经通过大量的数值检验被认为是正确的。这里可以编写一个简单的C++程序来验证并输出给定范围内的偶数分解：

#include <iostream>
#include <vector>
#include <cmath>

std::vector<int> sieve_of_eratosthenes(int n) {
    std::vector<bool> primes(n+1, true);
    primes[0] = primes[1] = false;

    for (int i = 2; i * i <= n; ++i) {
        if (primes[i]) {
            for (int j = i * i; j <= n; j += i)
                primes[j] = false;
        }
    }

    std::vector<int> result;
    for (int i = 2; i <= n; ++i) {
        if (primes[i])
            result.push_back(i);
    }

    return result;
}

void find_decompositions(int m, int n) {
    std::vector<int> primes = sieve_of_eratosthenes(n); // 获取小于等于n的所有素数

    for (int num = m; num <= n; num++) { // 遍历从m到n的每个偶数
        if (num % 2 == 0 && num >= 4) { // 只对大于等于4的偶数操作
            std::vector<int> factors;
            for (int prime : primes) { // 尝试找到素数因子
                if (prime > num / 2)
                    break;
                while (num % prime == 0) {
                    factors.push_back(prime);
                    num /= prime;
                }
            }
            if (num == 2) { // 如果还有2作为因子
                factors.push_back(2);
            }

            if (!factors.empty()) {
                std::cout << "Number: " << num << " can be decomposed as: ";
                for (int factor : factors) {
                    std::cout << factor << " + ";
                }
                std::cout << "2" << std::endl; // 根据哥德巴赫猜想，最后一个素数加2
            } else {
                std::cout << "Number: " << num << " cannot be decomposed into two primes." << std::endl;
            }
        }
    }
}

int main() {
    int m, n;
    std::cout << "Enter the range (m to n): ";
    std::cin >> m >> n;
    find_decompositions(m, n);
    return 0;
}

当你运行此程序并输入m和n值时，它会输出m到n之间的每个偶数及其对应的两个素数分解。