value by default for a pointer in a structure in C++

Question

I have a struct named Node which has 2 attributes: an int v and another Node* named child. If I do not explicitly provide a constructor for my struct, what value does child receive by default?

struct Node   
{
    int v;
    Node * child; 
};

It seems that it is not the NULL pointer, so I had to write a constructor inside my structure

struct Node   
{
    int v;
    Node * child; 
    // constructor
    Node():v(0),child(NULL){}
};

possible duplicate of [Why aren't pointers initialized with NULL by default?](http://stackoverflow.com/questions/1910832/why-arent-pointers-initialized-with-null-by-default) — AndyG, Jun 23 '15 at 01:31

score 4 · Answer 1 · answered Jun 23 '15 at 00:33

It will be uninitialised. Reading from it before setting its value in the constructor initialiser list, or the constructor body, is undefined behaviour.

Note that there are two exceptions: variables with static storage duration, and objects created with new Node() (as opposed to new Node). In both those cases, the object will be zero-initialised.

AnT stands with Russia · Answer 2 · 2015-06-23T01:45:39.577

The initial value of child pointer in this case will depend on external factors determined at the point of object definition: storage duration of Node object and initializer (if any).

If you declare a Node object with static storage duration, the pointer will be zero-initialized.

Node n1; // `n1.child` is null pointer

void foo()
{
  static Node n2; // `n2.child` is null pointer
}

If you declare a Node object with automatic storage duration and an initializer, the pointer will initialized as directed by the initializer
```
void foo()
{
  Node n3{}; // `n3.child` is null pointer
  Node n4 = { 42 }; // `n4.child` is null pointer
}
```
If you declare a Node object with automatic storage duration and no initializer, the pointer will not be initialized at all
```
void foo()
{
  Node n5; // `n5.child` is garbage value
}
```

If you allocate a Node object dynamically with an initializer, the pointer will initialized as directed by the initializer

Node *n6 = new Node(); // `n6->child` is null pointer
Node *n7 = new Node{}; // `n7->child` is null pointer
Node *n8 = new Node{ 42 }; // `n8->child` is null pointer

If you allocate a Node object dynamically without an initializer, the pointer will not be initialized at all
```
Node *n9 = new Node;   // `n9->child` is garbage value
```
If you declare Node as a subobject of a bigger object, the initialization rules propagate from bigger object to Node subobject.

If you want your class members to be zero-initialized in all cases, you can explicitly write a constructor or use C++11 member initializer syntax

struct Node   
{
    int v = 0;
    Node *child = nullptr; 
};

Thanks a lot! Actually I wrote in my code Node * foo = new Node; so Child was not initialized. Thanks for the idea of nullptr from C++11 :-) — Aurélie JEAN, Jun 24 '15 at 01:24

value by default for a pointer in a structure in C++

2 Answers2