Question

Why is it that for user defined types when creating an array of objects every element of this array is initialized with the default constructor, but when I create an array of a built-in type that isn’t the case?

And second question: Is it possible to specify default value to be used while initializing elements in the array? Something like this (not valid):

char* p = new char[size]('\0');

And another question in this topic while I’m with arrays. I suppose that when creating an array of user defined type, every element of this array will be initialized with default value. Why is this?

If arrays for built in types do not initialize their elements with their defaults, why do they do it for User Defined Types?

Is there a way to avoid/circumvent this default construction somehow? It seems like bit of a waste if I for example have created an array with size 10000, which forces 10000 default constructor calls, initializing data which I will (later on) overwrite anyway.

I think that behaviour should be consistent, so either every type of array should be initialized or none. And I think that the behaviour for built-in arrays is more appropriate.

Answer 1

Something like this (not valid):

As far as I know that is perfectly valid.
Well not completely, but you can get a zero intialized character array:

#include <iostream>
#include <cstdlib>

int main(int argc, char* argv[])
{
    //The extra parenthesis on the end call the "default constructor"
    //of char, which initailizes it with zero.
    char * myCharacters = new char[100]();
    for(size_t idx = 0; idx != 100; idx++) {
        if (!myCharacters[idx])
            continue;
        std::cout << "Error at " << idx << std::endl;
        std::system("pause");
    }
    delete [] myCharacters;
    return 0;
}

This program produces no output.

And another question in this topic while I’m with arrays. I suppose that when creating an array of user defined type and knowing the fact that every elem. of this array will be initialized with default value firstly why?

Because there’s no good syntactic way to specialize each element allocated with new. You can avoid this problem by using a vector instead, and calling reserve() in advance. The vector will allocate the memory but the constructors will not be called until you push_back into the vector. You should be using vectors instead of user managed arrays anyway because new’d memory handling is almost always not exception safe.

I think that behaviour should be consistent, so either every type of array should be initialized or none. And I think that the behaviour for built-in arrays is more appropriate.

Well if you can think of a good syntax for this you can write up a proposal for the standard — not sure how far you’ll get with that.

Why is it that for user defined types when creating an array of objects every element of this array is initialized with the default constructor, but when I create an array of a built-in type that isn’t the case? and
And another question in this topic while I’m with arrays. I suppose that when creating an array of user defined type, every element of this array will be initialized with default value. Why is this? and
If arrays for built in types do not initialize their elements with their defaults, why do they do it for User Defined Types?
Because a user defined type is never ever valid until its constructor is called. Built in types are always valid even if a constructor has not been called.

And second question: Is it possible to specify default value to be used while initializing elements in the array? Something like this (not valid):
Answered this above.

Is there a way to avoid/circumvent this default construction somehow? It seems like bit of a waste if I for example have created an array with size 10000, which forces 10000 default constructor calls, initializing data which I will (later on) overwrite anyway.
Yes, you can use a vector as I described above.