Why doesn't C++ require a "new" statement to initialize std::vector?

Question

Consider:

/* bar.h */
class bar{
    /* Standard stuff omitted */
    std::vector<my_obj*> foo;
};

/* bar.cpp */
bar::bar(){
    // foo = new std::vector<my_obj*>(); <-- Why don't I need this line??
    foo.push_back(new my_obj());
}

Why does this code work even though we didn't assign foo a new instance of std::vector?

Answer 1

Because C++ is not C#/Java.

std::vector<my_obj*> foo;

This is a definition of an object, not a reference as in C#/Java. An object is a living instance of a type.

new std::vector<my_obj*>()

This expression returns a pointer. It returns a std::vector<my_obj*>*, which is not the same type as foo (the * at the end is what makes them different). foo is an object, std::vector<my_obj*>* is a pointer to an object.

Objects (rather than pointers or references) have specific lifetimes. If you create a pointer to an object with new, the lifetime of the object pointed to will be until you explicitly call delete. If you create an object as a member of another object, then that inner object's lifetime will (more or less) mirror the outer object's lifetime. If you create an object on the stack (a parameter or variable at function scope), then its lifetime is the current scope of that variable name.

Answer 2

Because bar contains a std::vector, not a std::vector *.

It's really no different to something like this:

class bar
{
    int foo;  // No need to create a "new int"
};

Answer 3

Because foo is an object, not a pointer.

std::vector<my_obj*>    // This is an object
std::vector<my_obj*> *  // This is a pointer to an object
                    ^^^ // Notice the extra star.

new returns a pointer:

new std::vector<my_obj*>();  // returns std::vector<my_obj*> *

PS. Your vector should probably contain objects, not pointers.

std::vector<my_obj>   foo;
...
foo.push_back(my_obj());

Otherwise you will need to manually delete all the objects in the vector when it goes out of scope (when the containing object is destroyed). I.e., if you want to keep pointers in your vector you should do one of the following:

// 1. Manually delete all the elements in the vector when the object is destroyed.
~bar::bar()
{
    for(std::vector<my_obj*>::iterator loop = foo.begin(); loop != foo.end(); ++loop)
    {
        delete (*loop);
    }
}

// 2. Use a smart pointer:
std::vector<std::shared_ptr<my_obj> >  foo;

// 3. Use a smart container for pointers
boost::ptr_vector<my_obj>   foo

Answer 4

Because std::vector does that for you :) You don't have a pointer to std::vector, you're simply setting up an object of type std::vector, which internally allocates memory for you.