Почему я не могу получить доступ к указателю на указатель для массива стека?

Пожалуйста, взгляните на следующий код. Он пытается передать массив как char**функцию:

#include <stdio.h>
#include <stdlib.h>

static void printchar(char **x)
{
    printf("Test: %c\n", (*x)[0]);
}

int main(int argc, char *argv[])
{
    char test[256];
    char *test2 = malloc(256);

    test[0] = 'B';
    test2[0] = 'A';

    printchar(&test2);            // works
    printchar((char **) &test);   // crashes because *x in printchar() has an invalid pointer

    free(test2);

    return 0;
}

Тот факт, что я могу получить его только для компиляции, явно приведя &test2к char**уже намекам, что этот код неверен.

Тем не менее, мне интересно, что именно не так об этом. Я могу передать указатель на указатель на динамически размещенный массив, но не могу передать указатель на указатель для массива в стеке. Конечно, я легко могу обойти проблему, сначала назначив массив временной переменной, например так:

char test[256];
char *tmp = test;
test[0] = 'B';
printchar(&tmp);

Тем не менее, кто - то может объяснить мне , почему он не работает в гипсе , char[256]чтобы char**напрямую?

Потому что testэто не указатель.

&testполучает указатель на массив типа char (*)[256], который не совместим с char**(потому что массив не является указателем). Это приводит к неопределенному поведению.

testявляется массивом, а не указателем, и &testявляется указателем на массив. Это не указатель на указатель.

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

• Массив является операндом sizeof.
• Массив является операндом &.
• Массив - это строковый литерал, используемый для инициализации массива.

В &test, массив является операндом &, поэтому автоматического преобразования не происходит. Результатом &testявляется указатель на массив из 256 char, который имеет тип char (*)[256], а не char **.

Чтобы получить указатель на указатель на charfrom test, сначала нужно создать указатель на char. Например:

char *p = test; // Automatic conversion of test to &test[0] occurs.
printchar(&p);  // Passes a pointer to a pointer to char.

Еще один способ подумать об этом - понять, что testимена всего объекта - целого массива из 256 char. Он не называет указатель, поэтому в &testнем нет указателя, адрес которого можно взять, поэтому он не может создать char **. Для того чтобы создать char **, вы должны сначала иметь char *.

Тип test2есть char *. Таким образом, тип &test2будет , char **который совместим с типом параметра xв printchar().
Тип testесть char [256]. Таким образом, тип &testбудет , char (*)[256]который не совместим с типом параметра xв printchar().

Позвольте мне показать вам разницу с точки зрения адресов testи test2.

#include <stdio.h>
#include <stdlib.h>

static void printchar(char **x)
{
    printf("x = %p\n", (void*)x);
    printf("*x  = %p\n", (void*)(*x));
    printf("Test: %c\n", (*x)[0]);
}

int main(int argc, char *argv[])
{
    char test[256];
    char *test2 = malloc(256);

    test[0] = 'B';
    test2[0] = 'A';

    printf ("test2 : %p\n", (void*)test2);
    printf ("&test2 : %p\n", (void*)&test2);
    printf ("&test2[0] : %p\n", (void*)&test2[0]);
    printchar(&test2);            // works

    printf ("\n");
    printf ("test : %p\n", (void*)test);
    printf ("&test : %p\n", (void*)&test);
    printf ("&test[0] : %p\n", (void*)&test[0]);

    // Commenting below statement
    //printchar((char **) &test);   // crashes because *x in printchar() has an invalid pointer

    free(test2);

    return 0;
}

Вывод:

$ ./a.out 
test2 : 0x7fe974c02970
&test2 : 0x7ffee82eb9e8
&test2[0] : 0x7fe974c02970
x = 0x7ffee82eb9e8
*x  = 0x7fe974c02970
Test: A

test : 0x7ffee82eba00
&test : 0x7ffee82eba00
&test[0] : 0x7ffee82eba00

Укажите, чтобы отметить здесь:

Выход (адрес памяти) из test2и &test2[0]является численно одинаковы и их тип и тот же , который char *.
Но есть test2и &test2разные адреса и их тип тоже разный.
Тип test2есть char *.
Тип &test2есть char **.

x = &test2
*x = test2
(*x)[0] = test2[0] 

Выход (адрес памяти) из test, &testи &test[0]является числовым же , но их тип отличается .
Тип testесть char [256].
Тип &testесть char (*) [256].
Тип &test[0]есть char *.

Как показывает вывод, так &testже, как &test[0].

x = &test[0]
*x = test[0]       //first element of test array which is 'B'
(*x)[0] = ('B')[0]   // Not a valid statement

Следовательно, вы получаете ошибку сегментации.

Вы не можете получить доступ к указателю на указатель, потому что &testэто не указатель - это массив.

Если вы берете адрес массива, приводите массив и адрес массива к ним (void *)и сравниваете их, они (за исключением возможной педантизации указателей) будут эквивалентны.

То, что вы действительно делаете, похоже на это (опять же, за исключением строгого алиасинга):

putchar(**(char **)test);

что совершенно очевидно неправильно.

Ваш код ожидает аргумент xо printcharк точке в память, содержащий (char *).

В первом вызове он указывает на хранилище, используемое для, test2и, таким образом, действительно является значением, указывающим на a (char *), последний указывает на выделенную память.

Во втором вызове, однако, нет места, где (char *)можно было бы хранить какое-либо такое значение, и поэтому невозможно указать на такую ​​память. Приведение к (char **)вам добавило бы устранение ошибки компиляции (о преобразовании (char *)в (char **)), но это не привело бы к тому, что хранилище казалось бы пустым, чтобы содержать (char *)инициализированный указатель на первые символы теста. Приведение указателя в C не меняет фактическое значение указателя.

Чтобы получить то, что вы хотите, вы должны сделать это явно:

char *tempptr = &temp;
printchar(&tempptr);

Я предполагаю, что ваш пример - это фрагмент кода гораздо большего размера; Например, возможно, вы хотите printcharувеличить (char *)значение, на которое xуказывает переданное значение, чтобы при следующем вызове был напечатан следующий символ. Если это не так, почему бы вам просто не передать (char *)указание на символ, который будет напечатан, или даже просто передать сам символ?

Очевидно, что взятие адреса testтакое же, как взятие адреса test[0]:

#include <stdio.h>
#include <stdlib.h>

static void printchar(char **x)
{
    printf("[printchar] Address of pointer to pointer: %p\n", (void *)x);
    printf("[printchar] Address of pointer: %p\n", (void *)*x);
    printf("Test: %c\n", **x);
}

int main(int argc, char *argv[])
{
    char test[256];
    char *test2 = malloc(256);

    printf("[main] Address of test: %p\n", (void *)test);
    printf("[main] Address of the address of test: %p\n", (void *)&test);
    printf("[main] Address of test2: %p\n", (void *)test2);
    printf("[main] Address of the address of test2: %p\n", (void *)&test2);

    test[0] = 'B';
    test2[0] = 'A';

    printchar(&test2);            // works
    printchar(&test);   // crashes because *x in printchar() has an invalid pointer

    free(test2);

    return 0;
}

Скомпилируйте это и запустите:

forcebru$ clang test.c -Wall && ./a.out
test.c:25:15: warning: incompatible pointer types passing 'char (*)[256]' to
      parameter of type 'char **' [-Wincompatible-pointer-types]
    printchar(&test);   // crashes because *x in printchar() has an inva...
              ^~~~~
test.c:4:30: note: passing argument to parameter 'x' here
static void printchar(char **x)
                             ^
1 warning generated.
[main] Address of test: 0x7ffeeed039c0
[main] Address of the address of test: 0x7ffeeed039c0 [THIS IS A PROBLEM]
[main] Address of test2: 0x7fbe20c02aa0
[main] Address of the address of test2: 0x7ffeeed039a8
[printchar] Address of pointer to pointer: 0x7ffeeed039a8
[printchar] Address of pointer: 0x7fbe20c02aa0
Test: A
[printchar] Address of pointer to pointer: 0x7ffeeed039c0
[printchar] Address of pointer: 0x42 [THIS IS THE ASCII CODE OF 'B' in test[0] = 'B';]
Segmentation fault: 11

Таким образом, основной причиной ошибки сегментации является то, что эта программа будет пытаться разыменовать абсолютный адрес 0x42(также известный как 'B'), который ваша программа не имеет разрешения на чтение.

Хотя с другим компилятором / машиной адреса будут другими: попробуйте онлайн! , но вы все равно получите это по какой-то причине:

[main] Address of test: 0x7ffd4891b080
[main] Address of the address of test: 0x7ffd4891b080  [SAME ADDRESS!]

Но адрес, который вызывает ошибку сегментации, может очень отличаться:

[printchar] Address of pointer to pointer: 0x7ffd4891b080
[printchar] Address of pointer: 0x9c000000942  [WAS 0x42 IN MY CASE]

Представление char [256]зависит от реализации. Это не должно быть так же, как char *.

Приведение &testтипа char (*)[256]к типу char **приводит к неопределенному поведению.

С некоторыми компиляторами он может делать то, что вы ожидаете, а с другими нет.

РЕДАКТИРОВАТЬ:

После тестирования с gcc 9.2.1 выясняется, что оно printchar((char**)&test)фактически передается test как приведенное значение char**. Это как если бы инструкция была printchar((char**)test). В printcharфункции xуказатель на первый символ теста массива, а не двойной указатель на первый символ. Двойная де-ссылка xприводит к ошибке сегментации, потому что 8 первых байтов массива не соответствуют действительному адресу.

Я получаю точно такое же поведение и результат при компиляции программы clang 9.0.0-2.

Это может рассматриваться как ошибка компилятора или как результат неопределенного поведения, результат которого может зависеть от компилятора.

Другое неожиданное поведение заключается в том, что код

void printchar2(char (*x)[256]) {
    printf("px: %p\n", *x);
    printf("x: %p\n", x);
    printf("c: %c\n", **x);
}

Выход

px: 0x7ffd92627370
x: 0x7ffd92627370
c: A

Странное поведение таково xи *xимеет одинаковое значение.

Это вещь компилятора. Я сомневаюсь, что это определяется языком.