C++ 指针和 C 样式数组初始化

Question

Long time java programmer here, new to C++. I have been working with C-style "traditional" arrays (similar to arrays in java). I understand in C++ we can create a simple array as follows:

Person people[3];

The contents of this array is essentially uninitialized junk values. When I print out the contents of each element in the array, I (believe) am getting the memory address of each element.

for(int i = 0; i < 3; i++){std::cout << &person[i] << std::endl;}

Results:

//Note, I get different results here when I use an enhanced for loop vs an iterator for loop. Weird.
00EFFB6C
00EFFBA8
00EFFBE4

Now, here is the part I have failed to get a clear explanation on. I create a pointer to one of the elements in the array. I then ask for some value back from that pointer. In java, I would expect to get a null pointer, but in C++, that is not happening.

Instead, I get the default value, as though this element is initialized:

Person* person1Ptr = &people[0];//Points to an uninitialized value
std::cout << person1Ptr->getFirstName() << std::endl;//Output: "Default First Name", expected nullptr

When I try to get the first name of an element using a reference, this doesn't work (presumably because the value doesn't exist).

Full paste of code: https://pastebin.com/cEadfJhr

From my research, C++ does NOT fill arrays with objects of the specified type automagically.

How is my person1Ptr returning a value?

Answer 1

I believe the problem stems from this misconception:

From my research, C++ does NOT fill arrays with objects of the specified type automagically.

C++ objects have value semantics. Defining a local variable of type T concretely creates a unique instance of that type, it is not a handle to a potential T . The expression Foo f; is conceptually equivalent to the Java expression Foo f = new Foo(); . Additionally, value semantics means assignment usually implies a copy. The C++ expression Foo f; Foo g = f; Foo f; Foo g = f; is conceptually equivalent to the Java expression Foo f = new Foo(); Foo g = f.Clone(); Foo f = new Foo(); Foo g = f.Clone(); .

In the case of an array, defining a local variable Foo f[3]; immediately creates three instances of Foo as elements of the f array. Your misconception may come from the fact that creating an object in C++ does not imply that it has been initialized. An object can exist in an uninitialized state. For example int i; create an int object identified by i but its value is indeterminate. In the case of int i[3]; you would have an array of three int each with indeterminate values.

The rules for initialization are very complicated in C++. In the case of Person people[3]; you have an array that is default initialized .

You are initializing an object of type Person[3] . According to default initialization rules:

if T is an array type, every element of the array is default-initialized;

That means each Person gets its own default initialization. To see what happens, consider that T is Person :

if T is a class type, the constructors are considered and subjected to overload resolution against the empty argument list. The constructor selected (which is one of the default constructors) is called to provide the initial value for the new object;

So each Person 's default constructor will be called to initialize that element. You end up with Person people[3]; defining three default constructed Person objects with default initial values.