Why is int array not initialized to zeros in C++?

Question

I have a basic program in C++ which lists a given number of primes. The class which does the work is below - my question is, when the input for "amount" is 10 (specifically 10 - it works fine for all other numbers I've tried), the array that is generated just below is not initialized to an array of zeros. Hence, "the last element of the array is empty" returns false, and my code does not get to run properly.

I don't know whether I've misunderstood, but shouldn't the int array initialize to zeros? If not, what is special about the integer 10 which causes it to initialize to strange values?

int* primecalc(int amount) {

int* primes = new (nothrow) int [amount];

//Throw an error if we can't allocated enough memory for the array.
if (primes==0) {
cout<< "Error allocating memory.";
return 0;
}

//Otherwise, start iterating through the numbers.
else {
primes[0] = 2;
primes[1] = 3;

int p = 2;

for (int i=4;primes[amount]==0;i++) {
int j = 0;
int k = 0;

    while ((primes[j]<=floor(i/2)) && !(primes[j]==0) && (k==0)) {

        if ((i % primes[j]) == 0) {
        k=1;
        } 
    j++;
    } //end the while loop

if (k==0) {
        primes[p] = i;
        p++;

}

} //end the for loop

} //end the "else" part (this was only necessary in case memory could not be allocated)

return primes;
}

I also tried without (nothrow), with the same result. Thanks in advance for any help!

Note that primes[amount]==0 invokes undefined behaviour. The valid indices into primes are 0 through amount-1. — Daniel Fischer
– Daniel Fischer, Commented Aug 4, 2012 at 23:21

ildjarn · Accepted Answer · 2012-08-05 07:40:22Z

int* primes = new (nothrow) int[amount]; is using default-initialization, which for scalars like int is a noop (i.e. no actual initialization is performed).

If you want explicit initialization, use value-initialization instead:

int* primes = new (nothrow) int[amount]();

From the C++11 standard, §8.5/6:

To default-initialize an object of type T means:

if T is a (possibly cv-qualified) class type, the default constructor for T is called (and the initialization is ill-formed if T has no accessible default constructor);

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

otherwise, no initialization is performed.

If a program calls for the default initialization of an object of a const-qualified type T, T shall be a class type with a user-provided default constructor.

§8.5/7:

To value-initialize an object of type T means:

if T is a (possibly cv-qualified) class type with a user-provided constructor, then the default constructor for T is called (and the initialization is ill-formed if T has no accessible default constructor);

if T is a (possibly cv-qualified) non-union class type without a user-provided constructor, then the object is zero-initialized and, if T’s implicitly-declared default constructor is non-trivial, that constructor is called.

if T is an array type, then each element is value-initialized;

otherwise, the object is zero-initialized.

An object that is value-initialized is deemed to be constructed and thus subject to provisions of this International Standard applying to “constructed” objects, objects “for which the constructor has completed,” etc., even if no constructor is invoked for the object’s initialization.

§8.5/6:

To zero-initialize an object or reference of type T means:

if T is a scalar type, the object is set to the value 0 (zero), taken as an integral constant expression, converted to T;

if T is a (possibly cv-qualified) non-union class type, each non-static data member and each base-class subobject is zero-initialized and padding is initialized to zero bits;

if T is a (possibly cv-qualified) union type, the object’s first non-static named data member is zero-initialized and padding is initialized to zero bits;

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

if T is a reference type, no initialization is performed.

And finally from §8.5/10:

An object whose initializer is an empty set of parentheses, i.e., (), shall be value-initialized.

(All emphasis mine.)

Diego Sevilla · Accepted Answer · 2012-08-04 23:17:45Z

3

It is done just for efficiency. Not in all occasions arrays have to be pre-filled with a value, so C++ does not do it by default.

If you use std::vector<int> instead of plain arrays (I recommend you to), you have a constructor to set an initial value that can be 0:

std::vector<int> v(10,0);  // 10 elements with 0

answered Aug 4, 2012 at 23:17

Diego Sevilla

29.1k4 gold badges62 silver badges91 bronze badges

2 Comments

ildjarn Over a year ago

Why the downvote? While the implication that one must use std::vector<> if they want initialization is misleading, I don't see anything in this answer that is incorrect.

Diego Sevilla Over a year ago

Well, I don't understand the downvote either, but SF is not an exact science, it seems. Also, I don't imply using vector for initializing. I say if the OP decides to do so. And I recommend it not just for initialization, but for better programming patterns, so humbly I don't see this misleading. Certainly, adding a vector constructor with a default value is much more clear than adding a pair of parentheses to a overlong and complicated new call, but that may be just my understanding.

Collectives™ on Stack Overflow

Why is int array not initialized to zeros in C++?

2 Answers 2

Comments

2 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related