如何从向量的大小声明数组？

Question

I am trying to copy a vector into an array however I don't know how to declare the array from the size of the vector.

Code:

int main() {
    vector<int> ivec = {1, 2, 3, 4, 5};
    constexpr size_t size = ivec.size();
    int arr[size];
    for(size_t i = 0; i < ivec.size(); ++i)
        arr[i] = ivec[i];
    for(size_t i : arr)
        cout << i << endl;
    return 0;
}

However, I think this won't compile because ivec.size() can't be a constant expression (though I'm not sure if this is the case). In which case how could I do this without having to manually enter the number of elements?

Answer 1

As of right now std::vector size() is not a constexpr , so you cannot use it in constexpr essions. As a result, you can try using the new keyword for dynamically sized arrays, but that would be pointless, as you're already using a vector.

vector<int> vi = {1, 2, 3, 4, 5};
int* arr = new int[vi.size()];
std::copy(vi.begin(), vi.end(), arr);
for (unsigned int i = 0; i < vi.size(); i++)
    std::cout << arr[i] << " ";
delete[] arr;

: You can use std::begin() with the second example because arr[] is an array but not with the first example because arr* is a pointer. However, std::copy() accepts both, so it should be fine.

initializer_list s can be used in constexpr essions:

constexpr initializer_list<int> il = {1, 2, 3, 4, 5};
int arr[il.size()];
std::copy(il.begin(), il.end(), std::begin(arr));
for (unsigned int i = 0; i < il.size(); i++)
    std::cout << arr[i] << " ";

Answer 2

In general, it is not possible to copy a vector into array, because, a usual array is constexpr , while vector size is not, it is of dynamic size. There are also dynamic arrays supported by some compilers, but then again, there size is never constexpr . I guess, you need just to use vector.

Answer 3

I don't know your motivation, but...

int main() {
    vector<int> ivec = {1, 2, 3, 4, 5};
    constexpr size_t size = ivec.size();
    int* arr = (int*)malloc( sizeof( int * size ) );
    for(size_t i = 0; i < ivec.size(); ++i)
        arr[i] = ivec[i];
    for(size_t i : arr)
        cout << i << endl;
    free( arr );
    return 0;
}

Answer 4

I'd avoid

constexpr size_t size = ivec.size();
int arr[size];

and do it like this

size_t size = ivec.size();
int* arr = new int[size];

and then you handle it like the constantly allocated array. Read more about dynamically allocated arrays. and don't forget to

delete[] array;

Answer 5

You need to allocate memory, because as you have said vector size is not a constant:

int main() {
    vector<int> ivec = { 1, 2, 3, 4, 5 };
    size_t size = ivec.size();
    int *arr = new int[size]; // allocate memory
    for (size_t i = 0; i < ivec.size(); ++i)
        arr[i] = ivec[i];
    for (size_t i = 0; i < size; ++i)
        cout << i << endl;
    delete [] arr;  // release memory
    return 0;
}

Answer 6

It seems you want to get hold of the number of the elements in an initializer list yielding a constexpr . The only way I'm aware of doing this is to use

#include <cstddef>
template <typename T, std::size_t N>
constexpr std::size_t size(T(&)[N]) {
    return N;
}

int main() {
    int vec[] = { 1, 2, 3, 4, 5 };
    constexpr std::size_t s = size(vec);

    int array[s];
    std::copy(std::begin(vec), std::end(vec), array);
}

If you really need to use a std::vector<T> as source, you'll need to allocate memory, probably using std::vector<T> in the first place! If you want to allocate the memory yourself you'd use it something like this:

std::vector<int> vec = { 1, 2, 3, 4, 5 };
std::unique_ptr<int[]> array(new int[vec.size()]);
std::copy(vec.begin(), vec.end(), array.get());

The use of std::unique_ptr<int[]> makes sure that the allocated memory is released automatically.

Answer 7

A constexpr is a Constant Expression which is an expression that is evaluated at compile-time. That it is known at compile-time is a fundamental trait of a constexpr .

Given this, you can see how it makes no sense to try to construct a non-dynamically-allocated C-style array at run time when the number of elements will only be known at run-time. The two ideas are orthogonal.

From a technical standpoint, you cannot initialize a constexpr from a non-constant-expression. vector::size() is non- constexpr , so as you suspect, it is not only not compilable, but it is also not logical from a design standpoint to try to construct a constexpr from it:

constexpr size_t size = ivec.size(); // NO GOOD!

All this being said, it's very rare to need to construct a C-style array from vector . You're already doing the Right Thing by using vector in the first place. Don't mess it all up now by copying it to a crappy array.

A vector is guaranteed to have contigious storage. What this means is you can use it just like a C-style array in most cases. All you need to do is pass the address (or reference) to the first element in the vector to whatever is expecting a C-style array and it will work just fine.

void AincentApiFunction (int* array, size_t sizeofArray);

int main()
{
  std::vector <int> v;
  // ...

  AincentApiFunction (&v[0], v.size());
}

Answer 8

In C++11 arrays may declared as runtime bound on the stack: (Note: this is only per the latest available draft: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3690.pdf and will likely not be standard, but g++ with -std=c++11 will allow it

Note that is is not constexpression:

8.3.4 Arrays [dcl.array]

D1 [ expressionopt] attribute-specifier-seqopt

Example from the standard:

void f(unsigned int n) {
    int a[n]; // type of a is “array of runtime bound of int”
}

So all you need to do is remove constexpr:

int main() {
    vector<int> ivec = {1, 2, 3, 4, 5};
    size_t size = ivec.size();                  // this is fine
    int arr[size];
    for(size_t i = 0; i < ivec.size(); ++i)
        arr[i] = ivec[i];
    for(size_t i : arr)
        cout << i << endl;
    return 0;
}

Your compiler may or may not allow this, so depends on how strictly standard you need to be