C99 гарантирует, что массивы непрерывны?

Мы должны начать с изучения того, что на самом деле представляет собой int a [5] [5]. Используемые типы:

• int
• массив [5] целых чисел
• массив [5] массивов

Нет задействованного массива [25] целых чисел.

Верно, что семантика sizeof подразумевает, что массив в целом является непрерывным. Массив [5] целых чисел должен иметь 5 * sizeof (int), и при рекурсивном применении [5] [5] должен иметь 5 * 5 * sizeof (int). Нет места для дополнительной набивки.

Кроме того, массив в целом должен работать при передаче в memset, memmove или memcpy с размером sizeof. Также должна быть возможность перебирать весь массив с помощью (char *). Итак, допустимая итерация:

int  a[5][5], i, *pi;
char *pc;

pc = (char *)(&a[0][0]);
for (i = 0; i < 25; i++)
{
    pi = (int *)pc;
    DoSomething(pi);
    pc += sizeof(int);
}

То же самое с (int *) будет неопределенным поведением, потому что, как сказано, здесь не задействован массив [25] из int. Использование союза, как в ответе Кристофа, тоже должно быть допустимым. Но есть еще один момент, еще больше усложняющий это, - оператор равенства:

6.5.9.6 Два указателя сравниваются равными тогда и только тогда, когда оба являются нулевыми указателями, оба являются указателями на один и тот же объект (включая указатель на объект и подобъект в его начале) или функцию, оба являются указателями на один за последним элементом того же массива объект, или один - указатель на один за концом одного объекта массива, а другой - указатель на начало другого объекта массива, который сразу же следует за первым объектом массива в адресном пространстве. 91)

91) Два объекта могут быть смежными в памяти, потому что они являются смежными элементами большего массива или соседними элементами структуры без заполнения между ними, или потому что реализация решила разместить их таким образом, даже если они не связаны. Если предыдущие операции с недопустимыми указателями (например, доступ за пределы массива) приводили к неопределенному поведению, последующие сравнения также производили неопределенное поведение.

Это означает:

int a[5][5], *i1, *i2;

i1 = &a[0][0] + 5;
i2 = &a[1][0];

i1 сравнивается как i2. Но при итерации по массиву с (int *) поведение по-прежнему не определено, поскольку оно изначально получено из первого подмассива. Он не преобразуется волшебным образом в указатель на второй подмассив.

Даже при этом

char *c = (char *)(&a[0][0]) + 5*sizeof(int);
int  *i3 = (int *)c;

не поможет. Он сравнивается с i1 и i2, но не получен ни из одного подмассива; это указатель на один int или в лучшем случае массив [1] из int.

Я не считаю это ошибкой в ​​стандарте. Это наоборот: если это разрешить, возникнет особый случай, который нарушит либо систему типов для массивов, либо правила арифметики указателей, либо и то, и другое. Это можно считать отсутствующим определением, но не ошибкой.

Таким образом, даже если структура памяти для [5] [5] идентична структуре [25], и тот же самый цикл с использованием (char *) может использоваться для итерации по обоим, реализация будет позволено взорваться, если один используется в качестве другого. Я не знаю, почему он должен или знаю какую-либо реализацию, которая могла бы, и, возможно, в Стандарте есть один факт, не упомянутый до сих пор, который делает его четко определенным поведением.А пока я буду считать его неопределенным и буду в безопасности.