How do I convert a std::vector<double> to a double array[]?

Kinda begs the question of why? You can access a vector as an array. What does an array do that a vector does not?Michael Dorgan
@Michael The typical use case I have is using a vector in my own code and needing to call a third-party function that takes an arrayMichael Mrozek
The terminology being thrown around is confusing. A pointer isn't an array. Do we want a pointer to the first element of an array, or an array?GManNickG
@MichaelDorgan incredibly, sometimes is necessary. For example when passing as argument to a CUDA kernelKansaiRobot
Zombie comment from 11 years ago - I love it :)Michael Dorgan

10 Answers


There's a fairly simple trick to do so, since the spec now guarantees vectors store their elements contiguously:

std::vector<double> v;
double* a = &v[0];

What for? You need to clarify: Do you need a pointer to the first element of an array, or an array?

If you're calling an API function that expects the former, you can do do_something(&v[0], v.size()), where v is a vector of doubles. The elements of a vector are contiguous.

Otherwise, you just have to copy each element:

double arr[100];
std::copy(v.begin(), v.end(), arr);

Ensure not only thar arr is big enough, but that arr gets filled up, or you have uninitialized values.


For C++11, vector.data() will do the trick.

vector<double> thevector;
double *thearray = &thevector[0];

This is guaranteed to work by the standard, however there are some caveats: in particular take care to only use thearray while thevector is in scope.


Vectors effectively are arrays under the skin. If you have a function:

void f( double a[]);

you can call it like this:

vector <double> v;
v.push_back( 1.23 )
f( &v[0] );

You should not ever need to convert a vector into an actual array instance.


As to std::vector<int> vec, vec to get int*, you can use two method:

  1. int* arr = &vec[0];

  2. int* arr = vec.data();

If you want to convert any type T vector to T* array, just replace the above int to T.

I will show you why does the above two works, for good understanding?

std::vector is a dynamic array essentially.

Main data member as below:

template <class T, class Alloc = allocator<T>>
class vector{
        typedef T          value_type;
        typedef T*         iterator;
        typedef T*         pointer;
        pointer start_;
        pointer finish_;
        pointer end_of_storage_;

        vector():start_(0), finish_(0), end_of_storage_(0){}

The range (start_, end_of_storage_) is all the array memory the vector allocate;

The range(start_, finish_) is all the array memory the vector used;

The range(finish_, end_of_storage_) is the backup array memory.

For example, as to a vector vec. which has {9, 9, 1, 2, 3, 4} is pointer may like the below.

enter image description here

So &vec[0] = start_ (address.) (start_ is equivalent to int* array head)

In c++11 the data() member function just return start_

pointer data()
     return start_; //(equivalent to `value_type*`, array head)

We can do this using data() method. C++11 provides this method.

Code Snippet

using namespace std;

int main()

  vector<int>v = {7, 8, 9, 10, 11};
  int *arr = v.data();

  for(int i=0; i<v.size(); i++)
    cout<<arr[i]<<" ";

  return 0;
std::vector<double> vec;
double* arr = vec.data();

If you have a function, then you probably need this:foo(&array[0], array.size());. If you managed to get into a situation where you need an array then you need to refactor, vectors are basically extended arrays, you should always use them.


You can do some what like this

vector <int> id;
vector <double> v;

if(id.size() > 0)
    for(int i = 0; i < id.size(); i++)
        for(int j = 0; j < id.size(); j++)
            double x = v[i][j];
            cout << x << endl;