std::vector initialization of class member

Question

I have read that std::vector always initializes it's objects with their default values say for an int it is 0. The same should be applicable even for classes where the default constructor is called. However the results shown by a test program are a bit different :-

#include <iostream>
#include <vector>
using namespace std;

class A 
{
    public:
      int i;
      A(){};
};

class B
{
    public:
        int i;
        B() = default;
};

template <typename T>
void seev (const vector<T> &v)
{
    for (auto &x:v)
    {
        cout << x.i << ' ';
    }
    cout << '\n';
}

int main()
{
    vector<int> vi(5);  // just to show that std::vector always default initializes values & hence int will be 0 here
    vector<A> va(5);
    vector<B> vb(5);

    for (auto x: vi)
    cout << x << ' ';
    cout << '\n';

    seev (va);
    seev (vb);
    return 0;
}

The output is :-

0 0 0 0 0
8854016 0 8847696 0 8854016
0 0 0 0 0

My question is why was the value of member i undefined for A & not for B ? What difference did the constructor signatures :-

A() {}

&

B() = default;

make ?

Answer 1

There is a difference between default initialization and value initialization. The difference is shown for B but not for A:

• When a class has a non-= defaulted constructor, this constructor is called when either default or value initialization is used. Its responsibility is to initialize all members appropriately.

• When a class either has no constructor or an = defaulted default constructor the initialization of the members depends on how the object is constructed: when initializing the object without parenthesis default initialization is done which leaves subobjects without a default constructor uninitialized. When initializing the object with parenthesis value initialization is done which value initializes all subobjects. Value initialization of built-in types mean they get a suitable zero value while default initialization of built-in types means they are left uninitialized.

Since A has an explicitly written default constructor, its constructor needs to initialize all members which aren't of class type with a default constructor. B has an implicitly written default constructor and default or value initialization is performed as necessary for the subobjects.

The objects in a std::vector<T> are constructed using T() (if no other arguments are provides as is the case, e.g., for push_back() or emplace_back()). For A members that means they are left uninitialized, for B members that means they are zero initialized.

Answer 2

When creating a vector with a specific size, the vector doesn't set default values, it uses something called value initialization which is something completely different.

For primitive types, like e.g. int, that means the value will be zero-initialized (i.e. zero). But for objects with constructors the default constructor (if it has one) will be used.

In the case of your A class, the default constructor does not initialize the i member variable, so it will be uninitialized and have an indeterminate value, by printing that value you have undefined behavior.

As for the B class it's a POD type which means that value initialization of the whole object will also value-initialize all members. B is a POD type because it has a trivial default constructor (which A does not have).