向量中的结构成员是否在C ++中初始化为零？

Question

In C++, when I have a struct like

struct myStruct
{
  int i;
  bool b;
  MyClass *myobj;
};

and I then make a vector of this

std::vector<myStruct> myVector;

and I resize the vector with

myVector.resize(10);

Will the struct's members be initialized with zero's (including the pointer)? Can I not assume that and might there be random data in the struct's members?

Answer 1

In this particular case, the answer is YES because of std::vector::resize() 's properties:

If the current size is less than count, additional elements are appended and initialized with copies of value.      (until C++11)

If the current size is less than count,  (since C++11)
    1) additional value-initialized elements are appended
    2) additional copies of value are appended

The answer will be NO for normal cases, eg myStruct s , this will leave them ( si, s.bool, s.myobj ) with indeterminate values .

If you still want them to be initialized as expected, create a constructor for the struct:

struct myStruct {
    int i;
    bool b;
    MyClass *myobj;

    myStruct():i(0),b(false),myobj(NULL) { }  // <- set them here by default
};

Answer 2

I actually beg to differ. In this particular case , the standard appears to guarantee that the objects will be zero-initialized. (All standard references below are to N3936.)

vector::resize in this case is specified to append 10 "default-inserted elements to the sequence" (§23.3.6.3 [vector.capacity]/p12).

Default-insertion is in turn defined as (§23.2.1 [container.requirements.general]/p14; X is the container's type; m is an lvalue of type A , which is the container's allocator_type ):

An element of X is default-inserted if it is initialized by evaluation of the expression

 allocator_traits<A>::construct(m, p) 

where p is the address of the uninitialized storage for the element allocated within X .

Since as written the code uses the default allocator, the allocator_traits::construct call simply calls construct(p) on an instance of std::allocator<myStruct> (§20.7.8.2 [allocator.traits.members]/p5), which is specified as (§20.7.9.1 [allocator.members]/p12)

 template <class U, class... Args> void construct(U* p, Args&&... args); 

12 Effects : ::new((void *)p) U(std::forward<Args>(args)...)

Since the parameter pack is empty for construct(p) , the effect of the construct() call is ::new((void *)p) myStruct() .

The standard provides that new-initializers , like the () in the placement new expression above, are to be interpreted "according to the initialization rules of 8.5 for direct initialization" (§5.3.4 [expr.new]/p17). In turn, §8.5 [dcl.init]/p11 specifies that "An object whose initializer is an empty set of parentheses, ie, () , shall be value-initialized."

Value-initialization is specified as (§8.5 [dcl.init]/p8)

To value-initialize an object of type T means:

• if T is a (possibly cv-qualified) class type (Clause 9) with either no default constructor (12.1) or a default constructor that is user-provided or deleted, then the object is default-initialized;
• if T is a (possibly cv-qualified) class type without a user-provided or deleted default constructor, then the object is zero-initialized and the semantic constraints for default-initialization are checked, and if T has a non-trivial default constructor, the object is default-initialized;
• if T is an array type, then each element is value-initialized;
• otherwise, the object is zero-initialized.

In this case, myStruct is a "class type without a user-provided or deleted default constructor", which means it matches the second bullet point, which performs zero-initialization. Thus, value-initialization for an object of type myStruct means the object will be zero-initialized.

However, note that the rules here are quite convoluted, and the path to automatic zero-initialization is quite fragile. For example, if you give myStruct a default constructor like myStruct() { } , then that's a user-provided default constructor, which means that it will match the first bullet point for value initialization instead of the second, which in turn means that it won't be zero-initialized. Moreover, this may also not work if your vector uses a custom allocator, as its construct() might have different semantics than that of the default allocator.

Therefore, it is probably better to give myStruct a default constructor that explicitly zeroes its members.

Answer 3

Yes the structs will be initialised to zero IN THIS PARTICULAR CASE. The reason is the implementation of the resize() method in the STL. New elements are default-constructed:

void resize(size_type __new_size) {
    resize(__new_size, value_type());
}

value_type() results in zero initialisation.

test evidence

#include <cstdio>

struct foo {
  int i;
  int j;
  void *k;
};

void test(const foo& fooinst) {
  printf("%d\n",fooinst.i);
}

main() {
  test(foo());
}

Here's the relevant part of the resulting g++ disassembly. Note the explicit zero initialisation of the struct members before the call.

test.cpp      ****   test(foo());
  56                            .loc 1 14 0
  57 002d C745F000              movl    $0, -16(%rbp)
  57      000000
  58 0034 C745F400              movl    $0, -12(%rbp)
  58      000000
  59 003b 48C745F8              movq    $0, -8(%rbp)
  59      00000000 
  60 0043 488D45F0              leaq    -16(%rbp), %rax
  61 0047 4889C7                movq    %rax, %rdi
  62 004a E8000000              call    _Z4testRK3foo

Answer 4

The values in the vector are initialised with the default constructor (or value initialised) of the struct , in this case myStruct .

The struct has no default constructor, so the compiler generated one will be used. In this case it leaves the objects of myStruct uninitialised.

No, in general, you cannot assume the data will be zero initialised.

This particular case (the .resize() ) is picking at a situation where there is value initialisation and there has been some change from C++03 and C++11 (other answers provide more detail).

Best advice remains , thing to do is add the default constructor that initialises the struct appropriately.

Answer 5

The ctor for the struct is called. Since you don't specify one (and you can, even for a struct), a default, do-nothing ctor is used. The default ctor does not clear the members.