Может ли соответствующая реализация С#define NULL быть чем-то дурацким

Ответ 1

В стандарте C99 в §7.17.3 указано, что NULL "расширяется до определенной константы нулевой указатель реализации". Между тем в §6.3.2.3.3 определяется константа нулевого указателя как "целочисленное константное выражение со значением 0 или такое выражение, которое применяется к типу void *". Поскольку нет другого определения для константы нулевого указателя, соответствующее определение NULL должно расширяться до целочисленного постоянного выражения с нулевым значением (или это отличено от void *).

Дальнейшее цитирование из C FAQ вопрос 5.5 (выделено мной):

В разделе 4.1.5 стандарта C указано, что NULL "расширяется до константы нулевого указателя, определяемой реализацией", что означает, что реализация получает выбор, какую форму 0 использовать, и использовать ли "void *"; см. вопросы 5.6 и 5.7. "Реализация, определенная здесь" здесь не означает, что NULL может быть #defined для соответствия некоторому ненулевому внутреннему значению нулевого указателя.

Это имеет смысл; поскольку стандарт требует константы нулевого целого в контекстах указателя для компиляции в нулевой указатель (независимо от того, имеет ли внутреннее представление машины значение, равное нулю), случай, когда NULL определяется как ноль, должен обрабатываться так или иначе, Программисту не требуется вводить NULL для получения нулевых указателей; это просто стилистическая конвенция (и может помочь уловить ошибки, например, когда NULL, определенный как (void *)0, используется в контексте не указателя).

Редактирование: одним из источников путаницы здесь представляется сжатый язык, используемый стандартом, т.е. он явно не говорит, что нет другого значения, которое можно было бы считать константой нулевого указателя. Однако, когда стандарт говорит, что "... называется константой нулевого указателя", это означает, что именно указанные определения называются константами нулевого указателя. Ему не нужно явно следовать каждому определению, указывая, что является несоответствующим, когда (по определению) стандарт определяет, что соответствует.

Ответ 2

Это немного расширяет некоторые другие ответы и делает некоторые моменты, которые другие пропустили.

Цитаты относятся к N1570 проекту стандарта ISO C 2011 года. Я не верю, что в этой области произошли значительные изменения со времени стандарта ANSI C 1989 года (что эквивалентно стандарту ISO ISO 1990). Ссылка, подобная "7.19p3", относится к подразделу 7.19, абзац 3. (Цифры в вопросе, похоже, относятся к стандарту ANSI 1989 года, в котором описывается язык в разделе 3 и в библиотеке в разделе 4, все выпуски стандарта ISO описать язык в разделе 6 и библиотеку в разделе 7.)

7.19p3 требует, чтобы макрос NULL расширялся до "константы нулевой указателя, определенной реализацией".

6.3.2.3p3 говорит:

Целочисленное постоянное выражение со значением 0 или такое выражение cast to type void *, называется константой нулевого указателя.

Так как константа нулевого указателя выделена курсивом, определение термина (3p1 указывает это соглашение) - это означает, что ничего другого, что указано, может быть константой нулевого указателя. (Стандарт не всегда строго следует этому соглашению для его определений, но нет никаких проблем, предполагая, что он делает это в этом случае.)

Итак, если мы "что-то неловкое", нам нужно посмотреть, что может быть "целочисленным постоянным выражением".

Константа нулевой указатель фразы должна приниматься как один термин, а не как фраза, смысл которой зависит от ее составных слов. В частности, целочисленная константа 0 является константой нулевого указателя, независимо от контекста, в котором она появляется; это не должно приводить к значению нулевого указателя, а к типу int, а не к типу указателя.

"Целочисленное постоянное выражение со значением 0" может быть любым из нескольких вещей (бесконечно много, если мы игнорируем пределы емкости). Литерал 0 является наиболее очевидным. Другие возможности: 0x0, 00000, 1-1, '\0' и '-'-'-'. (Из 100 слов ясно, что "значение 0" относится конкретно к этому значению типа int, но я думаю, что консенсус в том, что 0L также является допустимой константой нулевого указателя.)

Другое соответствующее предложение - 6.6p10:

Реализация может принимать другие формы постоянных выражений.

Не совсем понятно (мне), насколько широта это предназначено для разрешения. Например, компилятор может поддерживать бинарные литералы как расширение; то 0b0 будет действительной константой нулевого указателя. Это может также позволить ссылки на стиль С++ для объектов const, так что данный

const int x = 0;

ссылка на x может быть постоянным выражением (оно не находится в стандарте C).

Итак, ясно, что 0 - это константа нулевого указателя и что это правильное определение для макроса NULL.

В равной степени ясно, что (void*)0 является константой нулевого указателя, но это не допустимое определение для NULL, из-за 7.1.2p5:

Любое определение объектноподобного макроса, описанного в этом пункте, должно расширять до кода, который в полной мере защищен скобками, где это необходимо, так что он группируется в произвольном выражении, как если бы он был одним Идентификатор.

Если NULL расширен до (void*)0, то выражение sizeof NULL будет синтаксической ошибкой.

Так что насчет ((void*)0)? Ну, я на 99.9% уверен, что он должен быть корректным определением для NULL, но 6.5.1, который описывает заключенные в скобки выражения, говорит:

Выражение в скобках является основным выражением. Его тип и стоимость идентичны выражениям несферообразного выражения. Это lvalue, обозначение функции или выражение void, если unparenthesized выражение, соответственно, lvalue, функция указатель или выражение void.

Он не говорит, что константа нулевого указателя в скобках - это константа нулевого указателя. Тем не менее, насколько я знаю, все компиляторы C разумно предполагают, что константа нулевого указателя в скобках является константой нулевого указателя, делая ((void*)0 допустимым определением для NULL.

Что делать, если нулевой указатель представлен не как все биты-ноль, а как некоторые другие битовые шаблоны, например, один эквивалент 0xFFFFFFFF. Тогда (void*)0xFFFFFFFF, даже если он вычисляет нулевой указатель, не является константой нулевого указателя, просто потому, что он не удовлетворяет определению этого термина.

Какие другие варианты допускаются стандартом?

Поскольку реализации могут принимать другие формы постоянного выражения, компилятор мог бы определить __null как константное выражение типа int со значением 0, позволяя либо __null, либо ((void*)__null) как определение NULL. Он также мог бы сделать __null самой константой типа указателя, но он не мог бы использовать __null как определение NULL, так как он не удовлетворяет определению в 6.3.2.3p3.

Компилятор может выполнить одно и то же, без магии компилятора, например:

enum { __null };
#define NULL __null

Здесь __null представляет собой целочисленное константное выражение типа int со значением 0, поэтому его можно использовать везде, где может использоваться константа 0.

Преимущество, определяющее NULL в терминах символа, такого как __null, заключается в том, что компилятор может затем выдавать (возможно, необязательное) предупреждение, если NULL используется в константе без указателя. Например, это:

char c = NULL; /* PLEASE DON'T DO THIS */

совершенно легально, если NULL определяется как 0; расширение NULL на некоторый распознаваемый токен, такой как __null, облегчит компилятору обнаружение этой сомнительной конструкции.

Ответ 3

Ну, я нашел способ доказать, что

#define NULL ((void*)-1)

не является юридическим определением NULL.

int main(void) 
{ 
   void (*fp)() = NULL;   
}

Инициализация указателя функции с помощью NULL является законной и правильной, тогда как...

int main(void) 
{ 
   void (*fp)() = (void*)-1;   
}

... является нарушением ограничения, которое требует диагностики. Так что.

Но определение __builtin_magic_null_pointer NULL не пострадает от этой проблемы. Я все еще хотел бы знать, может ли кто-нибудь придумать причину, почему этого не может быть.

Ответ 4

Позднее, но никто не поднял этот вопрос: предположим, что реализация фактически использует

#define NULL __builtin_null

Мое чтение C99 заключается в том, что это прекрасно, пока специальное ключевое слово __builtin_null ведет себя как - если бы оно было либо "интегральным постоянным выражением со значением 0", либо "интегральным постоянным выражением со значением 0, отличным от void *". В частности, если реализация выбирает первый из этих параметров, то

int x = __builtin_null;
int y = __builtin_null + 1;

является допустимой единицей перевода, устанавливая x и y на целые значения 0 и 1 соответственно. Если он выбирает последний, то, конечно, оба являются нарушениями ограничений (6.5.16.1, 6.5.6 соответственно; void * не является "указателем на тип объекта" в 6.2.5p19; 6.7.8p11 применяет ограничения для присвоения инициализация). И я не понимаю, почему реализация будет делать это, если бы не обеспечить лучшую диагностику "неправильного использования" NULL, поэтому представляется вероятным, что для этого потребуется вариант, который сделал бы недействительным больше кода.

Ответ 5

Интегральное постоянное выражение с значение 0 или такое выражение cast to type void *, называется константа нулевой указатель.

NULL, который расширяется до определяемый реализацией нулевой указатель константа;

поэтому либо

NULL == 0

или

NULL == (void *) 0

Ответ 6

Константа нулевого указателя должна оценивать 0, иначе выражения типа !ptr не будут работать должным образом.

Макрос NULL расширяется до 0-значного выражения; AFAIK, это всегда было.