¿El bit std:: array es compatible con el viejo array C?

Esto no responde directamente a su pregunta, pero simplemente debe usar 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));

Si T es un tipo copiable trivialmente, se compilará hasta memcpy. Si no lo es, entonces esto hará la asignación de copia en cuanto a elementos y será correcta. De cualquier manera, esto hace lo Correcto y es bastante legible. No se necesita aritmética manual de bytes.

std::array proporciona el método data () que se puede usar para copiar a / desde una matriz de estilo c de tamaño adecuado:

const size_t size = 123;
int carray[size];
std::array<int,size> array;

memcpy( carray, array.data(), sizeof(int) * size );
memcpy( array.data(), carray, sizeof(int) * size );

Como se indica en la documentación

Este contenedor es un tipo agregado con la misma semántica que una estructura que contiene una matriz de estilo C T[N] como su único miembro de datos no estático.

Así que parece que la huella de memoria sería compatible con la matriz de estilo c, aunque no está claro por qué desea utilizar "hacks" con reinterpret_cast cuando hay una adecuada camino que no tiene ninguna sobrecarga.

El requisito en el método data() es que devuelva un puntero T* tal que:

[data(), data() + size()) es un rango válido, y data() == addressof(front()).

Esto implica que puede acceder a cada elemento secuencialmente a través del puntero data(), por lo que si T es trivialmente copiable, puede usar memcpy para copiar sizeof(T) * size() bytes a/desde un array T[size()], ya que esto es equivalente a memcpy ing cada elemento individualmente.

Sin embargo, no puede usar reinterpret_cast, ya que eso violaría estrictamente el aliasing, como data() no es necesario para que en realidad esté respaldado por un array - y también, incluso si tuviera que garantizar que std::array contiene un array, ya que C++17 no puede (incluso usando reinterpret_cast) enviar un puntero a un array a/desde un puntero a su primer miembro (tiene que usar std::launder).

array no exige mucho sobre el tipo subyacente sobre el que lo instancias.

Para tener cualquier posibilidad de resultados útiles al usar memcpy o reinterpret_cast para hacer una copia, el tipo sobre el que lo instanciaste tendría que ser trivialmente copiable. Almacenar esos elementos en un array no afecta el requisito de que memcpy (y tales) solo funcionen con tipos copiables trivialmente.

array se requiere que sea un contenedor contiguo y un agregado, que bastante mucho significa que el almacenamiento de los elementos debe ser una matriz. El estándar lo muestra como:

T elems[N]; // exposition only

Más tarde, sin embargo, tiene una nota que al menos implica que se requiere un array (§[array.sinopsis] / 4):

[Nota: La variable miembro elems se muestra solo para exposición, para enfatizar que array es un agregado de clase. El nombre elems no es parte de la interfaz del array. -nota final]

[subrayado añadido]

Note cómo es realmente solo el nombre específico elems que no es necesario.