取消引用具有相同地址的指针 returns 不同的结果

Question

这是我的代码：

#include "stdafx.h"
#include "math.h"
#include <iostream>

using namespace std;

double Calc_H(double Q, double Head, double *constants)
{
    return (constants[0] * pow(Q, 4) + constants[1] * pow(Q, 3) + constants[2] * pow(Q, 2) + constants[3] * Q + constants[4] - Head);
}

double Calc_dH(double Q, double *constants)
{
    return (4 * constants[0] * pow(Q, 3) + 3 * constants[1] * pow(Q, 2) + 2 * constants[2] * Q + constants[3]);
}

double NewtonRaphson(double Head, double first_guess, double max_error, double * constants)
{
    double Q_iter = first_guess;
    int iter_counter = 1;
    cout << constants << endl << constants[0] << endl << constants[1] << endl;
    while (abs(Calc_H(Q_iter, Head, constants)) > max_error || iter_counter > 1000)
    {
        Q_iter = Q_iter - Calc_H(Q_iter, Head, constants) / Calc_dH(Q_iter, constants);
        iter_counter++;
    }
    return Q_iter;
}

double * Calc_constants(double freq)
{
    double * pointer;
    double constants[6];
    constants[0] = -1.2363 + 2.3490 / 10 * freq - 1.3754 / 100 * pow(freq, 2) + 2.9027 / 10000 * pow(freq, 3) - 2.0004 / 1000000 * pow(freq, 4);
    constants[1] = 1.9547 - 4.5413 / 10 * freq + 3.5392 / 100 * pow(freq, 2) - 8.1716 / 10000 * pow(freq, 3) + 5.9227 / 1000000 * pow(freq, 4);
    constants[2] = -5.3522 - 4.5413 / 10 * freq - 1.3311 / 100 * pow(freq, 2) + 4.8787 / 10000 * pow(freq, 3) - 4.8767 / 1000000 * pow(freq, 4);
    constants[3] =  3.8894 / 100 + 3.5888 / 10 * freq + 1.0024 / 100 * pow(freq, 2) - 5.6565 / 10000 * pow(freq, 3) + 7.5172 / 1000000 * pow(freq, 4);
    constants[4] = -8.1649 + 5.4525 / 10 * freq - 3.2415 / 100 * pow(freq, 2) + 8.9033 / 10000 * pow(freq, 3) - 9.0927 / 1000000 * pow(freq, 4);
    constants[5] =  2.1180 / 10 + 5.0018 / 100 * freq + 6.0490 / 1000 * pow(freq, 2) - 1.5707 / 100000 * pow(freq, 3) + 3.7572 / 10000000 * pow(freq, 4);

    pointer = constants;
    return pointer;
}

int _tmain(int argc, _TCHAR* argv[])
{

    double * constants;
    //Determine constants based on freq (see manual pump)
    double freq;
    cin >> freq; 
    double head;
    cin >> head;
    constants = Calc_constants(freq);
    cout << constants[0] << endl << constants[1] << endl << constants << endl;
    cout << NewtonRaphson(head, 0, 0.001, constants) << endl;
    cin >> freq;    
    return 0;
}

函数 Calc_constants returns 一个指向计算值数组的指针。到目前为止一切顺利。

函数NewtonRaphson将指向该数组的指针作为参数。在此函数中取消引用此指针时，returns constants[0] 和 constants[1] 的结果不同。我觉得这很奇怪，因为指针 'pointing' 指向的地址是相同的。

澄清这是输出 (cout):

-0.09505
2.6008
OOD6F604
00D6F604
-9.25596e+0.61
-9.25596e+0.61
-1.08038e-0.62

Answer 1

double * Calc_constants(double freq)
{
    double * pointer;
    double constants[6];

Calc_constants 在栈上为这个数组分配内存，而不是在堆上。当这个函数 returns 时，这个内存块可能被分配用于其他目的，因此不应该在这个函数之外被访问。正因为如此，当返回指针，并在以后使用时，会导致不可预测的结果。

常量数组需要在主内存或堆上分配，因此它的生命周期足够长以适应这种使用。

在这个 while 循环条件下，

while (abs(Calc_H(Q_iter, Head, constants)) > max_error || iter_counter > 1000)

我猜应该是 iter_counter < 1000.

Answer 2

您的代码中没有太多 C++。首先，让我们删除非标准的东西：

#include "stdafx.h"
#include "math.h"
#include <iostream>

应该变成：

#include <math.h>
#include <iostream>

int _tmain(int argc, _TCHAR* argv[])

应该变成：

int main()

然后到处都是 C 风格的数组。你不想那样做。使用 std::array 或 std::vector 问题会自行消失。

这里有一个 std::vector 的例子：

#include <math.h>
#include <iostream>
#include <vector>

double Calc_H(double Q, double Head, std::vector<double> const& constants)
{
    return (constants[0] * pow(Q, 4) + constants[1] * pow(Q, 3) + constants[2] * pow(Q, 2) + constants[3] * Q + constants[4] - Head);
}

double Calc_dH(double Q, std::vector<double> const& constants)
{
    return (4 * constants[0] * pow(Q, 3) + 3 * constants[1] * pow(Q, 2) + 2 * constants[2] * Q + constants[3]);
}

double NewtonRaphson(double Head, double first_guess, double max_error, std::vector<double> const& constants)
{
    double Q_iter = first_guess;
    int iter_counter = 1;
    std::cout << constants.data() << std::endl << constants[0] << std::endl << constants[1] << std::endl;
    while (abs(Calc_H(Q_iter, Head, constants)) > max_error && iter_counter < 1000)
    {
        Q_iter = Q_iter - Calc_H(Q_iter, Head, constants) / Calc_dH(Q_iter, constants);
        iter_counter++;
    }
    return Q_iter;
}

std::vector<double> Calc_constants(double freq)
{
    std::vector<double> constants(6);
    constants[0] = -1.2363 + 2.3490 / 10 * freq - 1.3754 / 100 * pow(freq, 2) + 2.9027 / 10000 * pow(freq, 3) - 2.0004 / 1000000 * pow(freq, 4);
    constants[1] = 1.9547 - 4.5413 / 10 * freq + 3.5392 / 100 * pow(freq, 2) - 8.1716 / 10000 * pow(freq, 3) + 5.9227 / 1000000 * pow(freq, 4);
    constants[2] = -5.3522 - 4.5413 / 10 * freq - 1.3311 / 100 * pow(freq, 2) + 4.8787 / 10000 * pow(freq, 3) - 4.8767 / 1000000 * pow(freq, 4);
    constants[3] =  3.8894 / 100 + 3.5888 / 10 * freq + 1.0024 / 100 * pow(freq, 2) - 5.6565 / 10000 * pow(freq, 3) + 7.5172 / 1000000 * pow(freq, 4);
    constants[4] = -8.1649 + 5.4525 / 10 * freq - 3.2415 / 100 * pow(freq, 2) + 8.9033 / 10000 * pow(freq, 3) - 9.0927 / 1000000 * pow(freq, 4);
    constants[5] =  2.1180 / 10 + 5.0018 / 100 * freq + 6.0490 / 1000 * pow(freq, 2) - 1.5707 / 100000 * pow(freq, 3) + 3.7572 / 10000000 * pow(freq, 4);

    return constants;
}

int main()
{
    //Determine constants based on freq (see manual pump)
    double freq;
    std::cin >> freq; 
    double head;
    std::cin >> head;
    std::vector<double> constants = Calc_constants(freq);
    std::cout << constants[0] << std::endl << constants[1] << std::endl << constants.data() << std::endl;
    std::cout << NewtonRaphson(head, 0, 0.001, constants) << std::endl;
    std::cin >> freq;    
    return 0;
}

（我还修改了 while 循环，我猜这是你想要的。）

如您所见，元素访问与 C 数组具有相同的语法。指向std::vector 封装的数据的指针是用data() 获得的。我已经添加了这个，因为你的原始代码打印了数组的地址；对于此类应用程序，您很少需要在实际代码中使用 data()。

现在，就您的原始代码而言：

double * Calc_constants(double freq)
{
    double * pointer;
    double constants[6];
    // ...    
    pointer = constants;
    return pointer;
}

这只会产生未定义的行为。 constants 是局部变量。您在此处创建的六个元素在函数 returns 时被销毁，但您保留了指向它们的指针。如果您稍后尝试取消引用该指针（就像您所做的那样），C++ 语言不保证会发生什么。运气好的话，程序会立即崩溃，向您显示存在严重错误，而不是生成无意义的输出。

你也有点不走运，没有收到编译器警告。如果您没有使用冗余 pointer 变量，那么您可能会收到警告（至少在 VC 2013 中）。

简单示例：

double * Calc_constants()
{
    double constants[6];
    return constants;
}

int main()
{
    double* ptr = Calc_constants();
}

VC 2013 警告：

warning C4172: returning address of local variable or temporary

使用 std::vector，数据在内部分配，这样您就可以安全地 return 个对象。您可以像简单的 int 一样安全地使用标准容器对象，而不会在您的代码中散布原始指针的复杂性。

取消引用具有相同地址的指针 returns 不同的结果

Dereferencing pointer with same adress returns different result

c++

dereference