Is the std::array bit compatible with the old C array?

Question

Is the underlying bit representation for an std::array<T,N> v and a T u[N] the same?

In other words, is it safe to copy N*sizeof(T) bytes from one to the other? (Either through reinterpret_cast or memcpy.)

Edit:

For clarification, the emphasis is on same bit representation and reinterpret_cast.

For example, let's suppose I have these two classes over some trivially copyable type T, for some N:

struct VecNew {     std::array<T,N> v; };  struct VecOld {     T v[N]; }; 

And there is the legacy function

T foo(const VecOld& x); 

If the representations are the same, then this call is safe and avoids copying:

VecNew x; foo(reinterpret_cast<const VecOld&>(x)); 

Answer 1

This doesn't directly answer your question, but you should simply use std::copy:

T c[N]; std::array<T, N> cpp;  // from C to C++ std::copy(std::begin(c), std::end(c), std::begin(cpp));  // from C++ to C std::copy(std::begin(cpp), std::end(cpp), std::begin(c)); 

If T is a trivially copyable type, this'll compile down to memcpy. If it's not, then this'll do element-wise copy assignment and be correct. Either way, this does the Right Thing and is quite readable. No manual byte arithmetic necessary.