结构构造函数的问题导致堆栈溢出

Question

Both sections of code below are drastically simplified, isolated versions of my actual code. The examples are just big enough to reproduce the problem. The first section of code below works fine. The section section is an attempt to begin to make it part of a class. I'm trying to take tiny steps since small modifications to something like the struct shown below require lots of changes throughout the code which is full of pointers, pointer to pointers and references which all involve this struct. Can you tell me why the second section of code throws a stack overflow within it's constructor and what small changes can be made to fix it?

Working code:

#include <cstdio>
#include <cstdlib>
#include <iostream>

using std::cout;
using std::endl;

const int maxSize = 3;

struct Item{
    int count;
    Item *items[maxSize + 1];   
};

void foo()
{
    Item *p;
    p = new Item();
    p->count = 2;
    cout << p->count << endl;
}

int main(int argc, char *argv[])
{
    foo();
    return 0;
}

Attempt to very gradually modify the code as a whole toward becoming a class:

#include <cstdio>
#include <cstdlib>
#include <iostream>

using std::cout;
using std::endl;

int maxSize = 3;

struct Item{
    int count;
    Item *items;

    Item()
    {
        items = new Item[maxSize + 1]; // stack overflow
    }
};

void Initialize(int size)
{
    maxSize = size;
}

void foo()
{
    Item *p;
    p = new Item();
    p->count = 2;
    cout << p->count << endl;
}

int main(int argc, char *argv[])
{
    Initialize(5);
    foo();
    return 0;
}

Answer 1

构造Item的第一个调用称为new Item[maxSize+1] ，后者调用默认的构造函数，后者调用new Item[maxSize+1] ，后者调用默认的构造函数，依此类推，直到达到堆栈溢出为止。

Answer 2

It is because in working version you have reference to an array of object, but not actual object of Items . In second version, you are creating objects by using keyword new . So, in second version in constructor it will call itself! It will call it's own constructor infinite times. Hence, you see runtime exception stackoverflow :)

Answer 3

All the answers are right. I want to suggest a solution for you: Instead of initializing the array within the ctor, you could implement an initialization method like

init(int maxSize) {
  items = new Item[maxSize + 1];
}

that you can call after having constructed the object. This should avoid the stack overflow. In general, you should avoid to place instances of an object inside the object itself. Its better to use Collections of the Item List<Item>, std::vector<Item>, ...

Answer 4

Above posters are right. Within the constructor of Item you create items (by creating an array). So the ctor is again called, which creates more items, which .... This is more or less an infinite loop which eats up your stack. Either stick with the references or use a collection like List - so you can add the items later on dynamically.