Question

我被分配了一项任务来研究黎曼假设的变异。我在下面创建了以下工作正常，但我意识到，通过整数除法，我达到了一个我无法再运行测试结果的点（大约106次运行）。我不确定是否有任何其他可能导致我的程序在大约106次迭代后停止运行。有没有办法改进这些代码，以便我可以运行更多的测试结果？

#include <cstdlib>
#include <iostream>
#include <cmath>
#include <fstream>
using namespace std;

int omegaN(int n){
    int omega[100] = {};
    int sum = 0;
    for (int i = 1; i <= n; i++){
        if ((n%i) == 0 ){
            omega[i] = i;
        }
        sum += (omega[i]);
    }
    cout << "\nSum of omega: " << sum << endl;
    return sum;
}

double Hn (int n){
    double sum = 0;
    double h_n;
    double whatBraunWants = 0;
    for (int i = 1.0; i <= n; i++){
        h_n = 1.0/i;
        sum += h_n;
    }
    cout << "Sum of Hn: " << sum << endl;
    whatBraunWants = sum + log(sum) * exp(sum);
    cout << "What Hn plus natural log stuff equals: " << whatBraunWants << endl;
    return whatBraunWants;
}

int main(int argc, char** argv) {
    for (int i = 1; i <= 100; i++){
        cout << "\nUsing n = " << i;
        if (omegaN(i) <= Hn(i)){
            cout << "Good for when n = " << i << endl;
        }
        else{
            cout << "No good when n = " << i << endl;
        }
    }
    return 0;
}

Answer 1

好的，这有点棘手。在行

int omega[100] = {};

在omegaN(int n)内，您将数组omega的大小修改为100.但是，当omegaN的输入参数{{{}时，您执行越界访问1}}。你最终会覆盖一些你不应该做的记忆（未定义的行为），所以一切都会失败。

只需在堆栈上分配更多内容，例如n >= 100，或者更好，使用动态分配

int omega[1024];

并且不要忘记

int* omega = new int[n]; // now we know for sure we have enough storage space

delete[] omega;

之前的

- 来自return。

或者，更好的是，使用来自omegaN的智能指针（C ++ 11/14）并替换

<memory>

与

int omega[100];

std::unique_ptr<int[]> omega(new int[n]{}); // or use std::make_unique in C++14析构函数将负责释放内存。

PS：您也可以使用std::unique_ptr，但使用数组会更复杂一些，但遗憾的是std::shared_ptr没有专门化，您必须提供自定义删除器。

PPS：我还将T[]替换为i <= n用于循环条件，与前者一样，它可以轻松访问数组/指针的最后一个元素。< / p>

使用系列时提高精度

1 个答案: