Does putting data into std::vector in C++ create a copy of the data?

Question

I am interested if creating a new std::vector (or calling its assign method) creates a copy of the data?

For example,

void fun(char *input) {
    std::vector<char> v(input, input+strlen(input));
    // is it safe to assume that the data input points to was COPIED into v?
}

Thanks, Boda Cydo.

Answer 1

Yes. Elements are always copied into or out of STL containers. (At least until move semantics are added in C++0x)

EDIT: Here's how you can test for copying yourself:

#include <vector>
#include <iostream>

class CopyChecker
{
public:
    CopyChecker()
    {
        std::cout << "Hey, look! A new copy checker!" << std::endl;
    }
    CopyChecker(const CopyChecker& other)
    {
        std::cout << "I'm the copy checker! No, I am! Wait, the"
            " two of us are the same!" << std::endl;
    }
    ~CopyChecker()
    {
        std::cout << "Erroap=02-0304-231~No Carrier" << std::endl;
    }
};

int main()
{
    std::vector<CopyChecker> doICopy;
    doICopy.push_back(CopyChecker());
}

The output should be:

Hey, look! A new copy checker!
I'm the copy checker! No, I am! Wait, the two of us are the same!
Erroap=02-0304-231~No Carrier
Erroap=02-0304-231~No Carrier

Answer 2

Elements are always copied into or out of STL containers.

Although the element may just be a pointer, in which case the pointer is copied but not the underlying data

Answer 3

About the move semantics, here is how you could move the contents in C++0x if you wanted to:

void fun_move(char *input)
{
    std::vector<char> v;
    auto len = strlen(input);
    v.reserve(len);
    std::move(input, input+len, std::back_inserter(v));
}

Answer 4

If you want your data to be moved, use std::swap_ranges, but you have to allocate for memory first :

vector<T> v;
v.reserve(std::distance(beg, end));
std::swap_ranges(beg, end, v.begin());

Answer 5

If you do not want the object copy semantics, then you can create a vector of pointers-to-objects instead so that only the pointer is copied. However you then have to ensure that the pointers then remain valid for the lifetime of the container.