Por que não consigo acessar um ponteiro para ponteiro para uma matriz de pilhas?

Por favor, dê uma olhada no código a seguir. Ele tenta passar uma matriz como uma char**para uma função:

#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;
}

O fato de que eu só posso obtê-lo para compilar lançando explicitamente &test2para char**já sugere que este código está errado.

Ainda assim, estou me perguntando o que exatamente está errado sobre isso. Posso passar um ponteiro para um ponteiro para uma matriz alocada dinamicamente, mas não posso passar um ponteiro para um ponteiro para uma matriz na pilha. Obviamente, posso solucionar o problema facilmente, atribuindo primeiro a matriz a uma variável temporária, da seguinte maneira:

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

Ainda assim, alguém pode me explicar por que ele não funciona para lançar char[256]a char**diretamente?

Porque testnão é um ponteiro.

&testfornece um ponteiro para a matriz, do tipo char (*)[256]que não é compatível char**(porque uma matriz não é um ponteiro). Isso resulta em comportamento indefinido.

test é uma matriz, não um ponteiro e &test é um ponteiro para a matriz. Não é um ponteiro para um ponteiro.

Você pode ter sido informado de que uma matriz é um ponteiro, mas isso está incorreto. O nome de uma matriz é o nome de todo o objeto - todos os elementos. Não é um ponteiro para o primeiro elemento. Na maioria das expressões, uma matriz é automaticamente convertida em um ponteiro para seu primeiro elemento. Essa é uma conveniência que geralmente é útil. Mas há três exceções a esta regra:

• A matriz é o operando de sizeof .
• A matriz é o operando de & .
• A matriz é uma string literal usada para inicializar uma matriz.

Em &test, a matriz é o operando de &, portanto, a conversão automática não ocorre. O resultado de &testé um ponteiro para uma matriz de 256 char, que tem o tipo char (*)[256], nãochar ** .

Para obter um ponteiro para um ponteiro charde test, você primeiro precisa fazer um ponteiro para char. Por exemplo:

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

Outra maneira de pensar sobre isso é perceber que os testnomes de todo o objeto - toda a matriz de 256 char. Ele não nomeia um ponteiro; portanto, em &test, não há ponteiro cujo endereço possa ser obtido, portanto, isso não pode produzir a char **. Para criar um char **, você deve primeiro ter um char *.

O tipo de test2é char *. Portanto, o tipo de &test2será char **compatível com o tipo de parâmetro xde printchar().
O tipo de testé char [256]. Então, o tipo de &testserá char (*)[256]qual é não compatível com o tipo de parâmetro xdeprintchar() .

Deixe-me mostrar a diferença em termos de endereços testetest2 .

#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;
}

Resultado:

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

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

Aponte para observação aqui:

A saída (endereço de memória) de test2e &test2[0]é numericamente igual e seu tipo também é o mesmo que é char *.
Mas os endereços test2e &test2são diferentes e seu tipo também é diferente.
O tipo de test2é char *.
O tipo de &test2é char **.

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

A saída (endereço de memória) de test, &teste &test[0]é numericamente mesmo , mas seu tipo é diferente .
O tipo de testé char [256].
O tipo de &testé char (*) [256].
O tipo de &test[0]é char *.

Como mostra a saída &testé o mesmo que &test[0].

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

Portanto, você está recebendo uma falha de segmentação.

Você não pode acessar um ponteiro para um ponteiro porque &testnão é um ponteiro - é uma matriz.

Se você pegar o endereço de uma matriz, converter a matriz e o endereço da matriz em (void *)e compará-los, eles (exceto o pedantry de ponteiro possível) serão equivalentes.

O que você está realmente fazendo é semelhante a este (novamente, exceto com estrias alias):

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

o que é obviamente errado.

Seu código espera o argumento xdeprintchar que ponto a memória que contém uma(char *) .

Na primeira chamada, aponta para o armazenamento usado test2e, portanto, é realmente um valor que aponta para um(char *) , o último apontando para a memória alocada.

Na segunda chamada, no entanto, não existe um local onde esse (char *)valor possa ser armazenado e, portanto, é impossível apontar para essa memória. A transmissão (char **)adicionada adicionou um erro de compilação (sobre a conversão (char *)para (char **)), mas não faria com que o armazenamento aparecesse do nada para conter um(char *) inicializada para apontar para os primeiros caracteres do teste. A conversão de ponteiro em C não altera o valor real do ponteiro.

Para conseguir o que deseja, você deve fazer isso explicitamente:

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

Suponho que seu exemplo seja uma destilação de um pedaço de código muito maior; como exemplo, talvez você queira printcharincrementar o (char *)valor que o xvalor passado aponta para que, na próxima chamada, o próximo caractere seja impresso. Se não for esse o caso, por que você não passa um (char *)apontador para o personagem a ser impresso, ou apenas passa o próprio caractere?

Aparentemente, pegar o endereço de testé o mesmo que pegar o endereço de 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;
}

Compile isso e execute:

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

Portanto, a causa final da falha de segmentação é que este programa tentará desreferenciar o endereço absoluto 0x42(também conhecido como'B' ), que seu programa não tem permissão para ler.

Embora com um compilador / computador diferente, os endereços sejam diferentes: Experimente online! , mas você ainda conseguirá isso, por algum motivo:

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

Mas o endereço que causa a falha de segmentação pode muito bem ser diferente:

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

A representação de char [256]depende da implementação. Não deve ser o mesmo que char *.

Fundição &testde tipo char (*)[256]de char **rendimentos indefinido comportamento.

Em alguns compiladores, pode fazer o que você espera, e em outros não.

EDITAR:

Após testar com o gcc 9.2.1, parece que printchar((char**)&test)passa de fato test como valor convertido para char**. É como se a instrução fosse printchar((char**)test). Na printcharfunção, xé um ponteiro para o primeiro caractere do teste de matriz, não um ponteiro duplo para o primeiro caractere. Uma des-referência duplax resulta em uma falha de segmentação porque os 8 primeiros bytes da matriz não correspondem a um endereço válido.

Recebo exatamente o mesmo comportamento e resultado ao compilar o programa com o clang 9.0.0-2.

Isso pode ser considerado um bug do compilador ou o resultado de um comportamento indefinido cujo resultado pode ser específico do compilador.

Outro comportamento inesperado é que o código

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

A saída é

px: 0x7ffd92627370
x: 0x7ffd92627370
c: A

O comportamento estranho é isso xe*x tem o mesmo valor.

Isso é uma coisa do compilador. Duvido que isso seja definido pelo idioma.