Блог

Следующий фрагмент кода (правильно) выдает предупреждение на C и ошибку на C (с использованием gcc и g соответственно, протестировано с версиями 3.4.5 и 4.2.1; MSVC, похоже, не волнует):

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

Я могу понять и принять это.
Решение этой проблемы на C состоит в том, чтобы изменить b значение на a const char * const * , что запрещает переназначение указателей и не позволяет обойти const-корректность (C FAQ).

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

Однако в чистом C исправленная версия (с использованием const char * const * ) по-прежнему выдает предупреждение, и я не понимаю почему.
Есть ли способ обойти это без использования приведения?

Чтобы уточнить:

1. Почему это генерирует предупреждение в C? Это должно быть полностью безопасно для const, и компилятор C , похоже, распознает его как таковой.

2. Как правильно принять это char** в качестве параметра, заявив (и принудив компилятор), что я не буду изменять символы, на которые он указывает? Например, если бы я хотел написать функцию:

     void f(const char* const* in) {
      // Only reads the data from in, does not write to it
    }
     

И я хотел вызвать его на a char** , какой тип был бы правильным для параметра?

У меня была такая же проблема несколько лет назад, и это меня бесконечно раздражало.

Правила в C сформулированы проще (т. Е. Они не перечисляют исключения, такие как преобразование char** в const char*const* ). Следовательно, это просто не разрешено. Со стандартом C они включили больше правил, разрешающих подобные случаи.

В конце концов, это просто проблема в стандарте C. Я надеюсь, что в следующем стандарте (или техническом отчете) это будет рассмотрено.

Чтобы считаться совместимым, указатель источника должен быть const на непосредственно предшествующем уровне косвенности. Итак, это выдаст вам предупреждение в 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 correct» означает, что, за исключением const_cast и удаления приведений в стиле C const , вы никогда не сможете изменить const объект с помощью этих постоянных указателей или ссылок.

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

 void foo(const int*);
  

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

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

 char *y;

char **a = amp;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 = amp;x; // the type of *b is const char *, so set it 
         //     with amp;x which is const char* ..
         //     ..  so y is set to amp;x... oops;
*y = 43; // y == amp;x... so attempting to modify const 
         //     variable.  oops!  undefined behavior!
cout << x << endl;
  

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

Первоначально объявленные объекты const являются особенно особенными — компилятор может предположить, что они никогда не меняются. Однако, если b может быть присвоено значение a без приведения, то вы можете непреднамеренно попытаться изменить const переменную. Это не только нарушило бы проверку, которую вы просили выполнить компилятор, чтобы запретить вам изменять значение этой переменной — это также позволило бы вам нарушить оптимизацию компилятора!

В некоторых компиляторах это будет напечатано 42 , в некоторых 43 и других программа завершится сбоем.

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

HappyDude: ваш комментарий попал в точку. Либо язык C, либо компилятор C, который вы используете, обрабатывают const char * const * его принципиально иначе, чем язык C . Возможно, рассмотрите возможность отключения предупреждения компилятора только для этой исходной строки.

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

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

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

Это имеет немного другое значение, но обычно оно выполнимо и не использует приведение.

Я не могу получить ошибку при неявном преобразовании char ** в const char * const *, по крайней мере, в 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 nulln", 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: cl / TC / W4 / Wp64 test.c

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

Вывод с компиляцией в виде кода C : cl / 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 -Wall 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 -Wall test.C

нет вывода

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

 const volatile int *const serial_port = SERIAL_PORT;
  

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

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

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

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