What std::vector in C++ really is?

Question

Not so far I discovered, that I completely have no clue about nature of std::vector.

Let me explain:

Vector is growable, right? That means, inside it must somehow allocate/reallocate memory dynamically. Something like this:

class vector {
private:
    int *data;
};

Okay. But such definition implies the fact that if we pass std::vector to another function by reference or by value -- there will be no difference between this two types of parameter passing, and both function will be able to modify data (unless vector is passed as const).

BUT! I tried the following and my idea failed:

void try_to_modify(vector<int> v) {
    v[2] = 53;
}

int main() {
    vector<int> v(3);
    v[2] = 142;
    try_to_modify(v);
    cout << v[2] << '\n';    // output is: 142

    return 0;
}

So where's the truth? What std::vector really is?

Thank you.

Answer 1

std::vector is a container, which internally manages its memory and provides a custom copy constructor. In this copy constructor, new memory is allocated and the existing data is copied over, which makes it a expensive operation. If you want to pass a vector without copying the contained data, you can pass by const reference, for example, const std::vector<int>&.

Let's take a look how to implement a basic container like std::vector.

template <typename T>
class MyVector
{
public:
    MyVector (int size)
    : data_ (new T[size])
    , size_ (size)
    {}

    ~MyVector ()
    {
        delete [] data_;
    }

 private:
    T* data_ = nullptr;
    int size_ = 0;
};

If we copy such an object, we'll have two problems. First, as you noticed, the memory will point to the same location. Second, we will have two destructors that will destruct the same memory, resulting in a double-free. So, let's add a copy constructor, which will be invoked whenever a copy is made.

MyVector (const MyVector& other)
: size_ (other.size_)
{
    data_ = new T[size_];
    std::copy (other.data_, other.data_ + size_, data_);
}

MyVector& operator= (const MyVector& other)
{
    // allocate and copy here to allow for self-assignment
    auto newData = new T[other.size_];
    std::copy (other.data_, other.data_ + size_, newData);

    delete [] data_;

    size_  = other.size_;
    data_ = newData;

    return *this;
}

And that's how std::vector works internally.

Answer 2

This isn't so much a problem with vector as it is with pass-by-value and pass-by-reference arguments.

void try_to_modify (vector<int> vec) will send a copy of the original vector to the function and the function operates on a copy. The vector will copy the data when a copy is made. i.e. new pointer to new data.

However, if you define your function as: void try_to_modify(vector<int> & vec) then it will send the exact vector to the function and your function will operate on it.

Passing by reference is much faster for objects and is usually preferable, unless you have a specific need for a copy.