I am trying to assign a C array to a C++ std::array.
How do I do that, the cleanest way and without making unneeded copies etc?
When doing
int X[8];
std::array<int,8> Y = X;
I get an compiler error: "no suitable constructor exists".
4 Answers
There is no conversion from plain array to std::array, but you can copy the elements from one to the other:
std::copy(std::begin(X), std::end(X), std::begin(Y));
Here's a working example:
#include <iostream>
#include <array>
#include <algorithm> // std::copy
int main() {
int X[8] = {0,1,2,3,4,5,6,7};
std::array<int,8> Y;
std::copy(std::begin(X), std::end(X), std::begin(Y));
for (int i: Y)
std::cout << i << " ";
std::cout << '\n';
return 0;
}
15 Comments
T.C.
<array> guarantees you std::begin and std::end already; no need for <iterator>.
juanchopanza
@T.C. I can't find that, at least not in the C++11 standard. Do you have a reference?
Casey
@juanchopanza 24.6.5/1: "In addition to being available via inclusion of the
<iterator> header, the function templates in 24.6.5 [overloads of std::begin and std::end] are available when any of the following headers are included: <array>, <deque>, <forward_list>, <list>, <map>, <regex>, <set>, <string>, <unordered_map>, <unordered_set>, and <vector>."
Rakete1111
@stupidlearner
std::copy is as unsafe as std::copy_n. Why do you think std::copy_n is safe?
stupidlearner
@Rakete1111 I didn't say
copy_n is safe. I was thinking using copy_n will force the programer to think about the correct size to copy, thus reducing the possibility of hidden overflow bugs. But this seems not correct as it depends. Thanks for pointing out. |
1 Comment
Daniel Langr
IINW, you can even write
auto Y = std::to_array(X);.I know it's been a while, but maybe still useful (for somebody). The provided above solutions are great, however maybe you'd be interested in a less elegant, but possibly a faster one:
#include <array>
#include <string.h>
using namespace std;
double A[4] = {1,2,3,4};
array<double, 4> B;
memcpy(B.data(), A, 4*sizeof(double));
The array size can be determined in some other (more dynamic) ways when needed, here is just an idea. I have not tested the performance of both solutions.
The one proposed here requires to provide proper size, otherwise bad things can happen.
Edit:
Comments below made me do the tests and unless someone is really trying to squeeze max of the performance it's not worth it (test copied back and forth per loop):
B size:100000 tested copy vs memcpy on 100000 elements arrays with 100000 loop count:
** copy() = 9.4986 sec
** memcpy() = 9.45058 sec
B size:100000 tested copy vs memcpy on 100000 elements arrays with 100000 loop count:
** copy() = 8.88585 sec
** memcpy() = 9.01923 sec
B size:100000 tested copy vs memcpy on 100000 elements arrays with 100000 loop count:
** copy() = 8.64099 sec
** memcpy() = 8.62316 sec
B size:100000 tested copy vs memcpy on 100000 elements arrays with 100000 loop count:
** copy() = 8.97016 sec
** memcpy() = 8.76941 sec
5 Comments
SomeWittyUsername
It's simpler and more robust to use
sizeof(A) for the size argument in memcpy
Gizmo
Quite the bold statement "faster one" and one sentence later "Not tested for performance". AFAIK: stackoverflow.com/a/4707028/2548287 => std::copy is for the compiler the same as memcpy (i.e. std::copy calls memcpy, or just gets vectorized).
Radoslaw Garbacz
All valid comments. As I wrote it is <b>"possibly"</b> faster, as I have not test it. But your comment made me do the test, and the difference is not worth the ugliness of using "memcpy" - they almost the same, with "memcpy" being just slightly faster.
Ves
@SomeWittyUsername OMG! Please never calculate the size argument of
memcpy from the source. I beg you to always use the size of the destination object (B.size() in this case)SomeWittyUsername
@Ves If you're concerned about possible target buffer overflow there are other ways to deal with it and they are out of scope for this question. Your suggestion just switches the possible target buffer overflow with source buffer overflow.
In addition to @capatober's answer, here is a quick implemention if C++20 is not available:
template <class T, std::size_t N>
constexpr std::array<std::remove_cv_t<T>, N> to_array( T (&a)[N] ){
return [&]<std::size_t ... indexes>(std::index_sequence<indexes...>){
return std::array<std::remove_cv_t<T>, N>{ a[indexes]... };
}(std::make_index_sequence<N>{});
}
template< class T, std::size_t N >
constexpr std::array<std::remove_cv_t<T>, N> to_array( T (&&a)[N] ){
return [&]<std::size_t ... indexes>(std::index_sequence<indexes...>){
return std::array<std::remove_cv_t<T>, N>{ fwd(a)[indexes]... };
}(std::make_index_sequence<N>{});
}
Complete code: https://godbolt.org/z/asjMPx84q.
std::arrayhas no user defined constructors, because it was deemed important to keep its status as an aggregate type.