Thread: Value initialization using an empty pair of parentheses

Originally Posted by zephon

Code:

int *pi = new int;         // pi points to an uninitialized int
int *pi = new int();       // pi points to an int value-initialized to 0

This is correct. The parenthesis instruct the compiler we want to initialize the pointer. This much we understand from user defined objects. If I define my own class and then want to initialize it, I may write something like and call the class default constructor:

myClass* ptr = new myClass();

For built-in types like int, the presence of parenthesis are a simple instruction for the compiler to initialize the pointer. Since we aren't providing any value, it will initialize it to zero. What I find extremely odd is that you are seeing also an initialization to 0 on int *pi = new int. Try the following code and post the results:

Code:

#include <iostream>

int main() {

    int a = 13;

    int *pi = new int;
    int *pia = new int();
    int *pib = new int(a);

    std::cout << *pi << "   " << *pia << "    " << *pib;

}

It should output a random number, followed by 0, followed by 13.

With MinGW 4.4.1 I see 0 0 13. Could be random luck or could be that the compiler doesn't bother to leave it uninitialized. (In practice I doubt one would ever allocate a single built-in type instance, and 99% of the time you wouldn't use array new either.)

Hmm... the compiler being benign, for a change?

Seriously though, may be something somewhat recent. And something one can alter with some switch. I'm pretty sure I saw gcc with uninitialized pointers before and I seriously doubt it will work with -ansi -pedantic.

Try to add -ansi -pedantic to the compilation flags.

As for the array. No. It doesn't work. I also have that book somewhere. I honestly don't remember they ever making such a crude mistake. The book is one of the most recommended books to learn C++. What's the page where you see that syntax for the array?

EDIT: I flipped through and saw it. It's on page 134. And it works indeed. It value initializes the array elements to 0. Interesting. I do remember now seeing this before. What you cannot do however, contrary to non-array built in types is something like int *pia = new int[10] (3);. In this case, you'll need to explicitly initialize each member.

Code:

#include <iostream>

int main() {

    int *pi = new int[10];
    int *pia = new int[10]();

    std::cout << pi[7] << "   " << pia[7];

}

Returns a random number followed by 0 on VC++ 2008.

So, the fact the array is not working under MinGW is more troublesome.

This is what I could found on the standard -- after only a quick perusal -- that, according to my interpretation, seems to indicate gcc is not following it:

Originally Posted by 5.3.4-15

A new-expression that creates an object of type T initializes that object as follows:
— If the new-initializer is omitted:
— If T is a (possibly cv-qualified) non-POD class type (or array thereof), the object is default-
initialized (8.5). If T is a const-qualified type, the underlying class type shall have a user-declared default constructor.
— Otherwise, the object created has indeterminate value. If T is a const-qualified type, or a (possibly cv-qualified) POD class type (or array thereof) containing (directly or indirectly) a member of const-qualified type, the program is ill-formed;
— If the new-initializer is of the form (), the item is value-initialized (8.5);

Originally Posted by 8.5-5

To zero-initialize an object of type T means:
— if T is a scalar type (3.9), the object is set to the value of 0 (zero) converted to T;
— if T is a non-union class type, each nonstatic data member and each base-class subobject is zero- initialized;
— if T is a union type, the object’s first named data member is zero-initialized;
— if T is an array type, each element is zero-initialized;

Yes. It has to be a simple coincidence. But if:

for array sizes of one and two I always get 0 values in the array and for values bigger than two I get random values

Then you can always try this:

Code:

int main()
{

    int *ptr = new int[120];

    const int arr_size=2;
    int *px = new int[arr_size];
    for (size_t i  = 0; i < arr_size; ++i)
        std::cout << *(px + i) << std::endl;
    delete []px;
    delete[] ptr;

    return 0;
}

Let's use up some of the heap prior to your array.

Originally Posted by Mario F.

So, the fact the array is not working under MinGW is more troublesome.

This is what I could found on the standard -- after only a quick perusal -- that, according to my interpretation, seems to indicate gcc is not following it:

— if T is an array type, each element is zero-initialized;

Does that just mean an array on the stack, or also a pointer to an array on the heap?

Originally Posted by Mario F.

Code:

int main()
{

    int *ptr = new int[120];

    const int arr_size=2;
    int *px = new int[arr_size];
    for (size_t i  = 0; i < arr_size; ++i)
        std::cout << *(px + i) << std::endl;
    delete []px;
    delete[] ptr;

    return 0;
}

I've tried it and it made no difference if the first array was bigger than 2. If the first array was of size 1 or 2, then the second one would get random values. So I guess my assumption was correct.

Next I've tried this code:

Code:

int main()
{

    const unsigned arr_size = 5;
    int *ptr[arr_size];

    for (size_t i=0; i < arr_size; ++i)
        ptr[i] = new int ();

    for (size_t i  = 0; i < arr_size; ++i)
        std::cout << *ptr[i] << std::endl;

    for (size_t i  = 0; i < arr_size; ++i)
        delete ptr[i];

    return 0;
}

Now here if I use new int() all ints will be 0 initialized while if the brackets were missing, the values will be random (only the first one will be 0, but the reason is similar to the case described above). So default value initialization is correct for single built-in types in MinGW. Only the array initialisation is not correct.

Originally Posted by cpjust

Does that just mean an array on the stack, or also a pointer to an array on the heap?

Well, also an array on the heap, I'd think.
The provision is established in 5.3.4-15 ("If the new-initializer is of the form (), the item is value-initialized (8.5)") and provides no exception for T being an array.

Zero initializing when it's not required to isn't failing to follow the standard anyway.