Совместим ли бит std::array со старым массивом C?

Я говорю да (но стандарт этого не гарантирует).

Согласно [массиву]/2:

Массив представляет собой агрегат ([dcl.init.aggr]), который может быть инициализирован списком до N элементов, типы которых могут быть преобразованы в T.

И [dcl.init.aggr]:

агрегат – это массив или класс (предложение [класс]) с

• нет пользовательских, явных или унаследованных конструкторов ([class.ctor]),

• нет частных или защищенных нестатических элементов данных (пункт [class.access]),

• нет виртуальных функций ([class.virtual]) и

• нет виртуальных, частных или защищенных базовых классов ([class.mi]).

В свете этого "может быть инициализирован списком" возможен только в том случае, если в начале класса нет других членов и нет виртуальной таблицы.

Затем data() указывается как:

constexpr T* data() noexcept;

Возвращает: указатель, в котором [data(), data() + size()) является допустимым диапазоном, а data() == addressof(front()).

Стандарт в основном хочет сказать «он возвращает массив», но оставляет дверь открытой для других реализаций.

Единственная возможная другая реализация — это структура с отдельными элементами, и в этом случае вы можете столкнуться с проблемами алиасинга. Но, на мой взгляд, такой подход не добавляет ничего, кроме сложности. Нет ничего полезного в том, чтобы развернуть массив в структуру.

Таким образом, нет нет смысла не реализовывать std::array как массив.

Но лазейка есть.

Это не дает прямого ответа на ваш вопрос, но вы должны просто использовать 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));

Если T является тривиально копируемым типом, он скомпилируется до memcpy. Если это не так, то это будет выполнять поэлементное копирование и будет правильным. В любом случае, это правильно и вполне читабельно. Нет необходимости в ручной байтовой арифметике.

std::array предоставляет метод data(), который можно использовать для копирования в/из массива c-стиля правильный размер:

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 );

Как указано в документации.

Этот контейнер представляет собой агрегатный тип с той же семантикой, что и структура, содержащая массив C-стиля T[N] в качестве единственного нестатического члена данных.

так что кажется, что объем памяти будет совместим с массивом в стиле c, хотя неясно, почему вы хотите использовать «хаки» с reinterpret_cast, когда есть правильный способ, который не требует каких-либо накладных расходов.

Требование к методу data() состоит в том, чтобы он возвращал указатель T* таким образом, что:

[data(), data() + size()) — допустимый диапазон, а data() == addressof(front()).

Это означает, что вы можете получить доступ к каждому элементу последовательно с помощью указателя data(), и поэтому, если T тривиально копируется, вы действительно можете использовать memcpy для копирования sizeof(T) * size() байтов в/из массива T[size()], поскольку это эквивалентно memcpyобработке каждого элемента по отдельности.

Однако вы не можете использовать reinterpret_cast, поскольку это нарушило бы строгое сглаживание, так как data() не требуется фактически поддерживаться массивом, а также, даже если вы должны были гарантировать, что std::array содержит массив, поскольку С++ 17 вы не можете (даже используя reinterpret_cast) привести указатель на массив к/от указателя к его первому элементу (вы должны использовать std::launder).

array мало что говорит о базовом типе, для которого вы его создаете.

Чтобы иметь любую возможность получения полезных результатов от использования memcpy или reinterpret_cast для копирования, тип, для которого вы создали его экземпляр, должен быть тривиально копируемым. Хранение этих элементов в array не влияет на требование, чтобы memcpy (и подобные) работали только с тривиально копируемыми типами.

array должен быть непрерывным контейнером и агрегатом, что в значительной степени означает, что хранилищем для элементов должен быть массив. Стандарт показывает это так:

T elems[N]; // exposition only

Однако позже в нем есть примечание, которое, по крайней мере, подразумевает, что требуется массив (§[array.overview]/4):

[Примечание. Переменная-член elems показана только для демонстрации, чтобы подчеркнуть, что array является агрегатом класса. Имя elems не является частью интерфейса массива. — конец примечания]

[курсив добавлен]

Обратите внимание, что на самом деле не требуется только конкретное имя elems.