Чтобы считаться совместимым, исходный указатель должен быть константой на сразу предшествующем косвенном уровне. Так, это даст Вам предупреждение в GCC:

char **a;
const char* const* b = a;

, Но это не будет:

const char **a;
const char* const* b = a;

, С другой стороны, можно бросить его:

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

Вам был бы нужен тот же бросок для вызова функции f (), как Вы упомянули. Насколько я знаю, нет никакого способа сделать неявное преобразование в этом случае (кроме C++).

> Однако в чистом C, это все еще дает предупреждение, и я не понимаю, почему

Вы уже определили проблему - этот код не корректен константой. "Константа, корректная", означает, что, за исключением const_cast и бросков C-стиля, удаляющих константу, Вы никогда не можете изменять объект константы через те указатели константы или ссылки.

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

void foo(const int*);

, Как объявлено, нечто не имеет разрешение изменить целое число, на которое указывает его аргумент.

, Если Вы не уверены, почему код Вы отправили, не корректно константой, рассмотрите следующий код, незначительно отличающийся от кода HappyDude:

char *y;

char **a = &y; // a points to y
const char **b = a; // now b also points to y

// const protection has been violated, because:

const char x = 42; // x must never be modified
*b = &x; // the type of *b is const char *, so set it 
         //     with &x which is const char* ..
         //     ..  so y is set to &x... oops;
*y = 43; // y == &x... so attempting to modify const 
         //     variable.  oops!  undefined behavior!
cout << x << endl;

типы неконстанты могут только преобразовать в типы константы в особенности способы предотвратить любой обман 'константы' на типе данных без явного броска.

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

На некоторых компиляторах, это распечатает '42' на 'приблизительно 43' и других, программа откажет.

Редактирование - добавьте:

HappyDude: Ваш комментарий является пятном на. Или язык C или компилятор C, который Вы используете, символ константы обработок * константа * существенно по-другому, чем язык C++, рассматривает его. Возможно, рассмотрите глушение предупреждения компилятора для этой исходной строки только.

Редактирование - удалите: удаленная опечатка

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

char c = 'c';
char *p = &c;
char **a = &p;

const char *bi = *a;
const char * const * b = &bi;

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

Я не в состоянии получить ошибку при неявном кастинге символа ** к символу константы * константа *, по крайней мере, на MSVC 14 (VS2k5) и g ++ 3.3.3. GCC 3.3.3 проблемы предупреждение, которое я не абсолютно уверен, если это корректно в выполнении.

test.c:

#include <stdlib.h> 
#include <stdio.h>
void foo(const char * const * bar)
{
    printf("bar %s null\n", bar ? "is not" : "is");
}

int main(int argc, char **argv) 
{
    char **x = NULL; 
    const char* const*y = x;
    foo(x);
    foo(y);
    return 0; 
}

Вывод с компиляцией как C код: Вывод статьи / TC/w4/wp64 test.c

test.c(8) : warning C4100: 'argv' : unreferenced formal parameter
test.c(8) : warning C4100: 'argc' : unreferenced formal parameter

с компиляцией как код C++: Вывод статьи / TP/w4/wp64 test.c

test.c(8) : warning C4100: 'argv' : unreferenced formal parameter
test.c(8) : warning C4100: 'argc' : unreferenced formal parameter

с gcc: gcc - стенной test.c

test2.c: In function `main':
test2.c:11: warning: initialization from incompatible pointer type
test2.c:12: warning: passing arg 1 of `foo' from incompatible pointer type

Вывод с g ++: g ++ - Стенной тест. C

никакой вывод

Я вполне уверен, что ключевое слово константы не подразумевает, что данные не могут быть изменены / постоянные, только что данные будут рассматривать как только для чтения. Рассмотрите это:

const volatile int *const serial_port = SERIAL_PORT;

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

константа помогает оптимизатору компилятора? Нет. Нисколько. Поскольку constness может быть добавлен к и удален от данных до кастинга, компилятор не может выяснить, являются ли данные константы действительно постоянными (так как бросок мог быть сделан в различной единице перевода). В C++ у Вас также есть изменяемое ключевое слово еще более того.

char *const p = (char *) 0xb000;
//error: p = (char *) 0xc000;
char **q = (char **)&p;
*q = (char *)0xc000; // p is now 0xc000

то, Что происходит, когда попытка предпринята для записи в память, которая действительно только для чтения (ROM, например), вероятно, не определяется в стандарте вообще.