C++ vector passed by value: did I get it right?

Question

Let's say I have a struct like this:

struct typeA
{
    long first;
    string second
    double third;
};

If I declare

typeA myArray[100];

Then myArray is stored in the stack, consuming sizeof(typeA)*100 bytes of garbage data (until I store some actual data, at least).

Whenever I pass this array as a parameter, I'll always be passing a pointer to the first of the first element in the stack. So the pointer goes from stack to stack.

But if I declare

vector<int> myVector (4, 100);

Then the myVector object is actually stored in the stack, and it contains a pointer to the first element of an array of 4*sizeof(int) bytes stored in the heap, where the actual data is stored. So pointer goes from stack to heap.

Whenever I pass this vector as a parameter, if I add it to the parameter list like this:

vector<int> parameterVector

the function gets a copy of the myVector object and stores it in the stack.

But if I do it like this:

vector<int> &parameterVector

the function gets a reference to myVector stored in the stack, so I now have a variable stored in the stack, referencing a myVector object also stored in the stack, that contains a pointer to an array of actual elements stored in the heap.

Is this correct?

I have a few doubts here:

Do the actual elements get stored in a static array (the ones inherited from C, indicated with square brackets) in the heap?
Does the myVector object have just one pointer to the first element, or it has multiple pointers to each one of the elements?
So passing a vector by value doesn't pose much of a problem, since the only thing that gets copied is the vector object, but not the actual elements. Is that so?
If I got the whole thing wrong and the actual elements are copied as well when passing a vector parameter by value, then why does C++ allow this, considering it discourages it with static arrays? (as far as I know, static arrays always get passed as a reference to the first element).

Thanks!

If you pass a vector by value then the elements are copied too — Thomas Sparber
The declaration vector<typeA> &parameterVector declared parameterVector to be a reference to a vector of typeA elements, not a pointer. — Some programmer dude
And regarding vector<typeA> myVector (4, 100), that's not a valid declaration. It tries to create a vector of four elements, each element initialized to 100. But you can't initialize a typeA object to 100. — Some programmer dude
Yes, that's right @Joachim Pileborg. Sorry about the terminology confusion and the invalid declaration. I just edited it. — Floella
In C++ the default way of passing a variable to a function is by value. That is how int, char* etc are passed. Vectors are not special in that they simply follow the same rule. It is C-style arrays that are the odd-ball, by being inconsistent with everything else. — Neil Kirk

NathanOliver NathanOliver · Accepted Answer · 2015-11-06T13:36:18

Do the actual elements get stored in a static array (the ones inherited from C, indicated with square brackets) in the heap?

Typically the elements of the vector are stored in the free store using a dynamic array like

some_type* some_name = new some_type[some_size]

Does the myVector object have just one pointer to the first element, or it has multiple pointers to each one of the elements?

Typically a vector will have a pointer to the first element, a size variable and a capacity. It could have more but these are implementation details and are not defined by the standard.

So passing a vector by value doesn't pose much of a problem, since the only thing that gets copied is the vector object, but not the actual elements. Is that so?

No. copying the vector is an O(N) operation as it has to copy each element of the vector. If it did not then you would have two vectors using the same underlying array and if one gets destroyed then it would delete the array out from under the other one.

C++ vector passed by value: did I get it right?

2 Answers