I would like to be able to convert between std::vector and its underlying C array int* without explicitly copying the data.
Does std::vector provide access to the underlying C array? I am looking for something like this
vector<int> v (4,100)
int* pv = v.c_array();
EDIT:
Also, is it possible to do the converse, i.e. how would I initialize an std::vector from a C array without copying?
int pv[4] = { 4, 4, 4, 4};
vector<int> v (pv);
You can get a pointer to the first element as follows:
int* pv = &v[0];
This pointer is only valid as long as the vector is not reallocated. Reallocation happens automatically if you insert more elements than will fit in the vector's remaining capacity (that is, if v.size() + NumberOfNewElements > v.capacity(). You can use v.reserve(NewCapacity) to ensure the vector has a capacity of at least NewCapacity.
Also remember that when the vector gets destroyed, the underlying array gets deleted as well.
reserve(), then you can add elements up to the capacity you reserved, and guarantee that references and iterators are still valid.
std::vector<int> v(&pv[0], &pv[4]);, using the example you added to your question.
array_ref<T> and string_ref<T> class templates are very helpful for this purpose (neither is standard--yet, and I don't know of any open source implementations with those exact interfaces, but I have an enhanced_cstring<T> class template in the Boost-licensed CxxReflect library that has been most useful).In C++11, you can use vector::data() to get C array pointer.
int* pv = &(v[0]);
Note that this is only the case for std::vector<>, you cannot do the same with other standard containers (except for std::string).
Scott Meyers covers this topic extensively in his books.
std::string using its c_str() or data() members. Because of this, while the standard doesn't require strings to be stored contiguously in memory, it would be very odd and inefficient not to do so.deque vs vector), and c_str() would incur a hefty penalty the first time it's called. As it turned out, implementers all seem to have weighed up the trade-off and wanted nothing to do with it...If you have very controlled conditions, you can just do:
std::vector<int> v(4,100);
int* pv = &v[0];
Be warned that this will only work as long as the vector doesn't have to grow, and the vector will still manage the lifetime of the underlying array (that is to say, don't delete pv). This is not an uncommon thing to do when calling underlying C APIs, but it's usually done with an unnamed temporary rather than by creating an explicit int* variable.
One way of protecting yourself against size changes is to reserve the maximal space (or larger) that you will need:
std::vector<int> v(4,100); //Maybe need
v.reserve(40); //reallocate to block out space for 40 elements
This will ensure that push_backs won't cause reallocation of the existing data.
vector<int>share memory with an array, but you could have avector<int, some_allocator>share memory.