1

我有这个简单的程序，当我运行这个程序时，出现分段错误，我无法识别我的错误在哪里。欢迎任何帮助。（Di> = 27的分段错误）。关键是当我立即删除功能时，分段错误消失了。或者当我将函数转换为 void 函数时。我知道有内存泄漏，因为没有使用删除运算符，它会导致内存泄漏，但容易不负责分段错误（这个泄漏内存很远会产生分段错误）。为简单起见，我没有使用删除运算符。

 #include <iostream>
    #include<complex>
    using namespace std;
    const int Di=27;
    typedef struct {
         complex<double> Matrix[Di][Di][Di][Di];

        } O;

    O initializing(int );

    int main()
    {
    O * Operator=new O[1];
    int p;
    int n;
    Operator[0]=initializing(n);
    cout<<"hi";
    return 0;

    }



O initializing(int  point)
{
int i,j,m,n;
O *Operator=new O[1];
for(i=0;i<Di-1;i++)
    for(j=0;j<Di-1;j++)
        for(n=0;n<Di-1;n++)
            for(m=0;m<Di-1;m++)
            Operator[0].Matrix[i][j][m][n]=2;

            cout<<Operator[0].Matrix[Di-1][Di-1][Di-1][Di-1];
return Operator[0];


}
4

2 回答 2

3

您正在按值返回一个具有大数组的结构，并且它不适合堆栈。通过指针返回结构，并在调用者中取消引用该指针。它也可以帮助您避免内存泄漏。

O* initializing(int );

int main()
{
    O * Operator=new O[1];
    int p;
    int n;
    O *tmp = initializing(n);
    Operator[0] = *tmp;
    delete[] tmp;
    cout<<"hi";
    return 0;
 }
于 2012-07-21T13:48:33.860 回答
2

我认为问题在于，当按值返回对象时，可能会在堆栈上创建一个临时对象。使用Di=27，每个对象的大小都是几兆字节，这很可能会溢出堆栈。

通过初始化一个新对象以复制现有对象，您还分配（和泄漏）至少两倍于您需要的内存。

更好的选择可能是将对象通过引用传递给函数：

void initialise(O & o, int point) {
    for (/*blah blah*/)
        o.Matrix[i][j][m][n]=2;
}

或者给结构一个构造函数：

struct O {
    explicit O(int point) {
        for (/*blah blah*/)
            Matrix[i][j][m][n]=2;
    }

    complex<double> Matrix[Di][Di][Di][Di];
};

在任何情况下，请记住删除您分配的任何内容new；或者，更好的是，使用智能指针为您执行此操作。

于 2012-07-21T13:58:37.903 回答