# Are pointers initialized to nullptr in a vector?

This topic is 1764 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

## Recommended Posts

class A{...};

int main()
{
std::vector<A*> vec;
vec.resize(10);
std::cout<<(vec[9]==nullptr); //prints 1
}

?

?

?

I want to make sure this happens on every system.

Are pointers initialized to nullptr?

##### Share on other sites
I can't remember, but if you want to be 100% sure, you can do it explicitly:
vec.resize( 10, nullptr );

##### Share on other sites

They should be default initialized to 0 or nullptr, yes.

If it's a vector of ints, then each element should be the same value as doing:

int myInt = int();
assert(myInt == 0);


(without the assert, which is just to illustrate)

For a vector of pointers, they should be initialized with their default constructor:

int *myIntPtr = /* however you're supposed to default-initialize them - I'm not sure */;

Test this:

#include <iostream>

typedef int *IntPointer; //Just so I get the initialization syntax correct.

int main(int argc, char *argv[])
{
int intA; //Not garunteed to be initialized.
int intB = int(); //Default initialized.

std::cout << intA << " - " << intB << std::endl;

int *intPtrA;
int *intPtrB = IntPointer();

std::cout << intPtrA << " - " << intPtrB << std::endl;

return 0;
}

These will either output:

0 - 0
0 - 0

Or:

2293640 - 0      //The first value being whatever random piece of memory was left there, but the second still being 0.
0x35434 - 0x0

Depending on whether your compiler is default-constructing everything or not (sometimes done for debugging purposes to help catch mistakes).

std::vector::resize() - "If [the second argument is] not specified, the default constructor is used instead."

The default constructor for ints is 0 and for pointers is null (whether explicitly 0 or nullptr, I'm not sure, but it probably doesn't matter).

Also see this: http://stackoverflow.com/a/937257/1177073 , where someone actually quotes the standard.

Edited by Servant of the Lord

##### Share on other sites
Also, you should try to use vectors of objects, not vectors of pointers, unless you have a good reason not to. If you really do need pointers (say, because you are storing objects of different derived classes, to obtain polymorphism), you probably want to use a vector of unique_ptr.

##### Share on other sites

Every element of a vector gets initialized with its default value, which is NULL for pointers.

So the basic answer is “Yes”.

L. Spiro

##### Share on other sites
afaik the initial value is compiler related and not defined in standard. so you can't be sure 100%, but basically most compilers do it this way.

##### Share on other sites
ah, ok. thanks for correction.

##### Share on other sites

Also, you should try to use vectors of objects, not vectors of pointers, unless you have a good reason not to. If you really do need pointers (say, because you are storing objects of different derived classes, to obtain polymorphism), you probably want to use a vector of unique_ptr.

boost::ptr_vector is here for that idiom.

##### Share on other sites

Also, you should try to use vectors of objects, not vectors of pointers, unless you have a good reason not to. If you really do need pointers (say, because you are storing objects of different derived classes, to obtain polymorphism), you probably want to use a vector of unique_ptr.

boost::ptr_vector is here for that idiom.

My understanding is that boost::ptr_vector<blah> doesn't have any advantages over using std::vector<std::unique_ptr<blah>> now that we have move semantics. But I would love to learn something new, so please enlighten me.

##### Share on other sites
About the only advantage I know of is that the pointer containers propagate constness. That is if you have a const_iterator to a ptr_vector you can't modify the stored object through that iterator, but a const_iterator to a std::vector of std::unique_ptrs can still be used to modify the pointed to objects.