Почему я не могу преобразовать 'символ **' в 'символ константы* константа*' в C?

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

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

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

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

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

Разъясниться:
1) Почему это генерирует предупреждение в C? Это должно быть совершенно безопасно от константы, и компилятор C++, кажется, распознает его как таковой.
2) Что корректный путь состоит в том, чтобы пойти о принятии этого символа ** в качестве параметра при высказывании (и наличие компилятора осуществляет), что я не буду изменять символы, на которые это указывает? Например, если я хотел записать функцию:

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

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

59
задан 12 revs, 4 users 64% 10 September 2019 в 00:46
поделиться

6 ответов

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

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

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

58
ответ дан ForceBru 24 November 2019 в 18:30
поделиться

Чтобы считаться совместимым, исходный указатель должен быть константой на сразу предшествующем косвенном уровне. Так, это даст Вам предупреждение в 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++).

10
ответ дан Fabio Ceconello 24 November 2019 в 18:30
поделиться

> Однако в чистом 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++, рассматривает его. Возможно, рассмотрите глушение предупреждения компилятора для этой исходной строки только.

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

10
ответ дан JL2210 24 November 2019 в 18:30
поделиться

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

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

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

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

1
ответ дан wnoise 24 November 2019 в 18:30
поделиться

Я не в состоянии получить ошибку при неявном кастинге символа ** к символу константы * константа *, по крайней мере, на 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

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

0
ответ дан user7116 24 November 2019 в 18:30
поделиться

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

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, например), вероятно, не определяется в стандарте вообще.

0
ответ дан Tim Cooper 24 November 2019 в 18:30
поделиться
Другие вопросы по тегам:

Похожие вопросы: