c++ - 二维数组中的自动初始化对象？

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++标准相关部分:

Default constructors ... are called to create class objects of dynamic storage duration (3.7.4) created by a new-expression in which the new-initializer is omitted (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] 只初始化了两次:

1. 在使用 test[i] = new Test[layers[i]];
创建期间使用随机垃圾
2. 使用 test[i][j] = Test(counter);
临时对象的实际值