Question

当我寻找内存泄漏时，我发现了这个有趣的特性。我有

class Perseptron :
public Neiron
{
private:
 Neiron** neirons;
 }

在类的头文件中。在neirons[i][0]初始化后，我在调试器中看到neirons[i][1,2...n]字段已经在构造函数neirons[i][0]初始化之前初始化了neirons[i][1,2...n]字段值等值。

neirons = new Neiron*[layerCount];
for (int i=0;i<layerCount;++i)
{
    neirons[i] = new Neiron[this->eachLayerCount[i]];
    for (int j=0;j<this->eachLayerCount[i];++j)
    {
        if (i == 0) {
            neirons[i][j] = Neiron(2, this->inCount, this->eachLayerCount[i + 1], i, j);
            neirons[i][j].inX = this->inX;
        }
        else if(i!=layerCount-1) 
            neirons[i][j] = Neiron(2, this->eachLayerCount[i - 1], this->eachLayerCount[i + 1],i,j);
        else 
            neirons[i][j] = Neiron(2, this->eachLayerCount[i - 1], 1,i,j);
    } 
}

我的Neiron构造函数：

Neiron::Neiron(int limit,int inCount,int outCount,int layerN,int neironN)

Neiron::Neiron(){}

为什么？

修改

MCVE

class Test{
public:
int fieldA;
Test(int a)
{
    fieldA = a;//when a=3, why already fieldA=2 ?
}
Test()
{

}
 };

int main()
{
int layers[] = { 3,4,2 };
int counter = 0;
Test** test=new Test*[3];
for (int i = 0;i < 3;++i)
{
    test[i] = new Test[layers[i]];
    for (int j = 0;j < layers[i];++j)
    {
        test[i][j] = Test(counter);
        counter++;
    }
}
for (int i = 0;i < 3;++i) delete[] test[i];
delete[] test;
return 0;
}

Answer 1

使用new创建对象总是隐式调用构造函数，它是标准的一部分，这种方法非常方便。因此，编写neirons[i] = new Neiron[this->eachLayerCount[i]];意味着“创建包含Neiron类的N个对象的数组，并将指向该数组的指针存储到neirons[i]”。结果，分配了动态缓冲区，在其中创建了N个对象（构造函数被调用）。

当前案例与创建单个对象neirons[i] = new Neiron;没什么不同，您可能习惯于隐式构造函数调用。

C ++标准的相关部分：

调用默认构造函数...来创建动态的类对象存储持续时间（3.7.4）由new-expression创建，其中省略了new-initializer（5.3.4）......

修改

我可能误解了这个问题。看起来你想知道在只调用默认构造函数的时候初始化某些字段，这对它们没有任何作用。应该没有魔法，没有初始化的变量从动态内存中留下的垃圾中获取其值。如果您看到一些有意义的值而不是随机的东西或零，那么您可能已将新对象放入内存中，而该内存刚刚被用于同一目的。如果您不相信此解释，请创建MCVE，以便我们可以逐步重现和解释方案。

编辑2

感谢澄清，我现在看到了关注。以下是MCVE中的内容：

test[i] = new Test[layers[i]];

动态缓冲区已分配并填充layers[i]个对象。使用默认构造函数创建对象，因此它们的字段未初始化，但包含堆上的垃圾（例如，这些对象的fieldA设置为-842150451或任何其他无意义的值。）

for (int j = 0;j < layers[i];++j)
{
    test[i][j] = Test(counter);
    counter++;
}

此示例在右侧使用匿名对象，因此它实际上与此对象相同：

for (int j = 0;j < layers[i];++j)
{
    Test temporaryObject(counter);
    test[i][j] = temporaryObject;
    counter++;
}

程序使用参数化构造函数在堆栈上创建临时对象，然后用它初始化test [i] [j]，销毁临时对象并为下一个i / j重复它。

第一次迭代（i = 0，j = 0）在堆栈中分配未初始化的缓冲区来存储临时对象并为其调用参数化构造函数，因此您可以看到构造函数中的fieldA从垃圾变为零。然后临时对象用于初始化test[i][j]并被销毁，释放内存。

第二次迭代（i = 0，j = 1）分配完全相同的内存区域来存储临时对象（您可以通过检查&temporaryObject或检查参数化构造函数中的this来验证它。由于此内存包含以前用作剩余的剩余内容作为临时对象，因此您会看到构造函数将fieldA从0（从上一次迭代开始）更改为1.依此类推。

我想强调，上述过程仅与临时对象有关。 test[i][j]仅初始化两次：

使用test[i] = new Test[layers[i]];
来自test[i][j] = Test(counter);

在二维数组中自动初始化对象？

1 个答案:

修改

编辑2