How do I convert a `std::vector<double>`

to a `double array[]`

?

### 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 `double`

s. 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.

As to `std::vector<int> vec`

, vec to get `int*`

, you can use two method:

int* arr = &vec[0];

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{
public:
typedef T value_type;
typedef T* iterator;
typedef T* pointer;
//.......
private:
pointer start_;
pointer finish_;
pointer end_of_storage_;
public:
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.

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)
}
```