const 导致不兼容的指针类型。为什么只针对双指针？

Question

此问题已在 here 中得到解决。

建议的 duplicate 和当前给出的答案没有说明为什么首先给出的示例没有问题。主要是为什么不推理:

“const int ** 是指向 const int * 的指针，这与 int* 不同”

同时申请:

“const int * 是一个指向 const int 的指针，这与 int 不同”

---

我正在从不同的角度接近它，希望能得到另一种解释。

带有示例的代码。

#include <stdio.h>

void f_a (int const a){

    /*
     *  Can't do:
     *      a = 3;  //error: assignment of read-only parameter ‘a’
     *
     * Explanation: I can't change the value of a in the scope of the function due to the const
    */
    printf("%d\n", a);
}

void f_ptr_a_type1 (int const * ptr_a){
    /*
     * Can do this:
     *     ptr_a’ = 0x3;
     * which make dereferencig to a impossible.
     *     printf("%d\n", * ptr_a’);  -> segfault
     * But const won't forbid it.
     *
     *  Can't do:
     *      *ptr_a’ = 3;  //error: assignment of read-only parameter ‘* ptr_a’
     *
     * Explanation: I can't change the value of a by pointer dereferencing and addignment due to the int const
    */
}

void f_ptr_a_type2 (int * const ptr_a){
    /*
     * Can do this:
     *     *a = 3;
     *
     *  Can't do:
     *      ptr_a = 3;  //error: assignment of read-only parameter ‘ptr_a’
     *
     * Explanation: I can't change the value because the const is protecting the value of the pointer in the funcion scope
    */
}

void f_ptr_ptr_a (int const ** ptr_ptr_a){
    /*
     * Can do this:
     *     ptr_ptr_a = 3;
     *     * ptr_ptr_a = 0x3;
     *
     *  Can't do:
     *      ** ptr_ptr_a = 0x3;  //error: assignment of read-only parameter ‘**ptr_a’
     *
     * Explanation: Makes sense. Just follows the pattern from previous functions.
    */
}

int main()
{
    int a = 7;
    f_a(a);

    int * ptr_a = &a;
    f_ptr_a_type1(&a);
    f_ptr_a_type2(&a);

    int ** ptr_ptr_a = &ptr_a;
    f_ptr_ptr_a(ptr_ptr_a);  //warning: passing argument 1 of ‘f_ptr_ptr_a’ from incompatible pointer type [-Wincompatible-pointer-types]
}

公认的广泛接受的答案是这样的:

int ** isn't the same as const int** and you can't safely cast it

我的问题是为什么函数突然关心？

这里没有提示int不是int const:

int a = 7;
f_a(a);

它没有在这里提示，因为 int * 既不是 int const * 也不是 int * const:

int * ptr_a = &a;
f_ptr_a_type1(&a);
f_ptr_a_type2(&a);

但突然间它开始在双指针情况下提示。

• 正在寻找使用此术语和示例的解释？

• 为什么函数突然开始担心写入权限超出她的范围？

Answer 1

从例如char * 到 const char * 总是安全的。通过const char *，指向的数据不能修改，仅此而已。

另一方面，从 char ** 到 const char ** 的转换可能不安全 ，因此它是不允许隐含的。与其解释它，不如考虑以下代码:

void foo(const char **bar)
{
    const char *str = "test string";
    *bar = str; // perfectly legal
}

int main(void)
{
    char *teststr[] = {0};
    foo((const char **)teststr);
    // now teststr points to a `const char *`!

    *teststr[0] = 'x'; // <- attempt to modify read-only memory
                       //    ok in this line, there's no const qualifier on teststr!
}

如果在调用 foo() 时从 char ** 到 const char ** 的转换是隐式的，那么您将有一个隐式的转换 const 的方法。