Преобразование в char*** из char* [2][2]

Сначала давайте рассмотрим, как оператор индекса работает с массивом, объявленным следующим образом:

char* a[2][2] = {{"123", "456"}, {"234", "567"}};

Выражение a[0] дает одномерный массив {"123", "456"} типа char* [2].

То есть в этом выражении a[0] указатель массива a неявно преобразуется в указатель на его первый элемент типа char* (*)[2]. Обозначим это как p. И исходное выражение оценивается как *(p + 0), то есть *(char* (*)[2] + 0), то же самое, что *(char* (*)[2]) и, в свою очередь, то же самое, что char* [2].

Применив еще один индексный оператор к полученному одномерному массиву (первый элемент исходного двумерного массива), мы получим объект типа char*.

Теперь давайте рассмотрим оператор индекса с указателем b, объявленным следующим образом:

char*** b = (char***) a;

Указатель указывает на объем памяти, занимаемый массивом a, где хранится указатель на элемент массива a"123". То есть по этому адресу хранится объект типа char*, указывающий на первый символ строкового литерала «123».

В этом случае выражение b[0] получает значение этого указателя, и применив к этому значению еще один индексный оператор, вы получите символ '1' строкового литерала. Это значение '1' используется как указатель в этом вызове printf:

printf("%s", b[0][0]);

Что приводит к неопределенному поведению. То есть этот вызов со спецификацией преобразования %s пытается получить доступ к памяти, используя значение символа '1' как указатель на действительный объект, а это не так.

Основное различие между использованием выражений с индексными операторами для массива a и использованием выражений с индексными операторами для указателя b заключается в том, что для массива не считывается память, занимаемая массивом. Вместо этого одно и то же значение адреса объема памяти, занимаемого указателем на строковый литерал "123", просто интерпретируется сначала как char * ( * )[2], а затем как char ** . В то время как для выражений с индексными операторами, примененными к указателю b, считываются значения, на которые указывают выражения указателя char *** и char **.

Чтобы индексировать char ***, вам нужны указатели char **, указывающие на указатели char *.

char* a[2][2] имеет только char* указателей. Указатели char ** должны где-то существовать. Вам необходимо выделить память для указателей char **.

#include <stdio.h>
int main() {
    char* a[2][2] = {{"123", "456"}, {"234", "567"}};
    char **b[2] = {a[0], a[1]};
    char ***c = b;
    printf("%s\n", a[0][0]);
    printf("%s\n", b[0][0]);
    printf("%s\n", c[0][0]);
}

Если вы просто хотите ссылаться на a как на другую переменную, вы можете объявить указатель на массив:

char *a[2][2] = {/* ... */}

char *(*b)[2] = a;
puts(a[0][0]);
puts(b[0][0]);

Причина, по которой простое использование char *** не работает, заключается в том, что ожидается своего рода «массив указателей», где каждый элемент является указателем на отдельный блок, содержащий указатели на строки.

Но когда вы объявляете char *a[2][2], у вас есть массив 2 на 2 указателей непосредственно на строки. Вместо двух указателей на два отдельных массива строковых указателей у вас есть два смежных массива строковых указателей, один за другим в памяти.

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

Эта разница в расположении является причиной того, что вы не можете рассматривать многомерные массивы как указатели на указатели. Вы должны явно объявить указатель на массив, представляющий многомерный массив, который вы пытаетесь индексировать.