Thread: How vector manages space

This works because the vector makes a copy of what you put into it.

If it didn't do that, what use would the container have if you needed to keep the objects you have created around for the vector to work?!

When you insert something into a vector, it makes a copy of it, using the copy constructor of the object you are inserting. In your code, the compiler generates a suitable copy constructor for struct test automatically.

For example, the following code fails to compile, because the user-defined copy constructor is private (making the object non-copiable), and hence inaccessible for the vector.

Code:

#include <vector>

class A
{
    public:
        A() {}
    private:
        A(const A&); //private copy constructor
};

int main()
{
    std::vector<A> vec;
    A a; //OK
    vec.push_back(a); //error, copy constructor is inaccessible
}

I don't understand your point about stepping through the constructor of the vector. In your code the vector is a class member and will be constructed (correctly - as an empty vector) by the compiler-generated constructor of class abc. If the (compiler-generated) copy constructor of struct test is OK (in your code it is) there shouldn't be any problems pushing the local test instances (their copies) into the vector.

Are you having some problems or do you just want to be sure?

You won't understand vectors by reading the source code of an STL implementation. It's usually unreadable, due to various minor optimizations or whatever.

You might learn a lot by implementing one, though.

Anyway, regarding case 4, vector is returning the copy you created earlier. It is you who makes the copy. Try
A &test2 = vec2[0];
and there should be no copy constructor call.

Firstly the difference between the two vectors:

Code:

std::vector<A*> vec1;
std::vector<A> vec2;

The first is a vector of pointers. The vector will store a copy of the pointer to the object, and copying a pointer doesn't involve copying the object. Both the pointer inside the vector and the original pointer outside point to the same object. The original pointer may go out of scope, but if the vector lives longer, the object will still be accessible through the pointer stored in the vector.

If you use new to allocate objects, you are also responsible for delete'ing each instance, to avoid memory leaks.

It would be dangerous to do something like this:

Code:

std::vector<A*> ptr_vec;
A a; //local instance
ptr_vec.push_back(&a); //store address

In this case the vector contains the address of a local object. If the local object goes out of scope, the pointer stored in the vector becomes invalid. (This is the scenario that you originally seemed to worry about.)

2.

Code:

A test2 = vec2[0];

This involves copying, because you have declared another instance of type A (test2) which is distinct from what vec2[0] contains. The object needs to be copied over. Modifying test2 will have no effect on the object stored in the vector.

You can avoid the copy and declare a reference to an A instance (because operator[] actually returns a reference, not a copy):

Code:

A& test2 = vec2[0];

Now, test2 is referencing the same object that is stored in the vector. Anything you do to test2 will change the A object at vec2[0]. If that is what you want, fine.

Using a reference like that might be dangerous because for certain operations - e.g push_back, erase etc - the vector might move the objects it is storing around in memory or destruct them (for each container type find out which methods would invalidate iterators).

It is not entirely uncommon to use the returned reference temporarily (without declaring a separate reference). Supposing class A had a public int member value, you might do:

Code:

vec2[0].value = 42;

The code is just doing what you asked for. There is no real good way to avoid this - you may well WANT to do this under certain circumstances (e.g. you create a local vector within a function A, call some other functions (B, C, D, ...) and then destroy the vector again before you leave the function A) so completely forbidding it is a bad idea. It is just the same as "if there's a speed limit, doesn't mean that cars can't break this speed limit (currently)" - you just aren't supposed to do this.

Whether this actually fails in a particular case or not depends on what you do in your code and the next function - so it's not absolutely certain to ALWAYS fail - it may fail one case, and in another case work fine. This is of course the scary part!

It should of course return the same address as you pushed in - the point is rather that this address is now either unused or used for something else - and if it's unused, it would possibly be used if you change the code, add more local variables or call a different function someplace between your insertion in the vector and the use of it later on.

Note that there are other "breakable" ways to use vectors or other classes that store pointers to objects - if you use new to create a new object, inster this in a container class and then delete the object, you'll still have the objects address within the vector, and as long as the object's memory address hasn't been used for something else, it will still look "fine" in there.

--
Mats