Sign in to follow this  
lride

Are pointers initialized to nullptr in a vector?

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 this post


Link to post
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 this post


Link to post
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 this post


Link to post
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 this post


Link to post
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 this post


Link to post
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.

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

Sign in to follow this