为什么我不能访问堆栈数组的指针？

请看下面的代码。它尝试将数组作为a 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。它没有命名指针，因此in &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具有相同的值。

这是编译器。我怀疑这是由语言定义的。