Могу ли я использовать NULL в качестве замены значения 0?

Могу ли я использовать указатель NULL в качестве замены значения 0?

Нет, это небезопасно. NULL - это константа с нулевым указателем, которая может иметь тип int, но чаще имеет тип void * (в C) или иначе не может быть напрямую присвоена int (в C ++> = 11). Оба языка позволяют преобразовывать указатели в целые числа, но не обеспечивают неявное выполнение таких преобразований (хотя некоторые компиляторы предоставляют это как расширение). Более того, хотя обычно преобразование нулевого указателя в целое число приводит к получению значения 0, стандарт этого не гарантирует. Если вам нужна константа с типом int и значением 0, введите ее по буквам 0.

• Могу ли я с этим перейти к неопределенному поведению?

Да, в любой реализации, где NULL расширяется до значения с типом void * или любого другого, не присваиваемого напрямую int. Стандарт не определяет поведение вашего присваивания в такой реализации, поэтому его поведение не определено.

• допустимо ли работать с NULL таким образом?

Это плохой стиль, и он сломается в некоторых системах и при определенных обстоятельствах. Поскольку вы, кажется, используете GCC, он сломается в вашем собственном примере, если вы скомпилируете с параметром -Werror.

• Есть ли что-нибудь неправильное в использовании NULL в качестве числового значения в арифметических выражениях?

да. Числовое значение не гарантируется. Если вы имеете в виду 0, напишите 0, что не только хорошо определено, но и короче и яснее.

• И как в этом случае результат в C ++?

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

NULL - некоторая константа нулевого указателя. В C это может быть целочисленное постоянное выражение со значением 0 или такое выражение, приведенное к void*, причем последнее более вероятно. Это означает, что вы не можете предполагать, что NULL взаимозаменяемо с нулем. Например, в этом примере кода

char const* foo = "bar"; 
foo + 0;

Замена 0 на NULL не гарантирует корректной программы на C, потому что сложение между двумя указателями (не говоря уже о разных типах указателей) не определено. Это вызовет выдачу диагностики из-за нарушения ограничения. Операнды для добавления не будут действительны.

Что касается C ++, то здесь дело обстоит несколько иначе. Отсутствие неявного преобразования из void* в другие типы объектов означало, что NULL исторически определялся как 0 в коде C ++. В C ++ 03 вам, вероятно, это сойдет с рук. Но начиная с C ++ 11 его можно юридически определить как ключевое слово nullptr . Теперь снова возникает ошибка, так как std::nullptr_t не может быть добавлен к типам указателей.

Могу ли я использовать указатель NULL в качестве замены значения 0?

int i = NULL;

Правила различаются для разных языков и их версий. В некоторых случаях вы можете, а в других - нет. Тем не менее, не следует. Если вам повезет, ваш компилятор предупредит вас, когда вы попытаетесь это сделать, или, что еще лучше, не сможете скомпилировать.

В C ++ до C ++ 11 (цитата из C ++ 03):

[lib.support.types]

NULL - это константа нулевого указателя C ++, определяемая в настоящем международном стандарте.

Нет смысла использовать константу нулевого указателя как целое число. Тем не мение...

[conv.ptr]

Константа нулевого указателя представляет собой целочисленное постоянное выражение (5.19) rvalue целочисленного типа, значение которого равно нулю.

Так что технически это сработает, даже если это бессмысленно. Из-за этого технического характера вы можете столкнуться с плохо написанными программами, которые злоупотребляют NULL.

Начиная с C ++ 11 (цитата из последнего черновика):

[conv.ptr]

Константа нулевого указателя - это целочисленный литерал ([lex.icon]) с нулевым значением или prvalue типа std :: nullptr_t.

std​::​nullptr_­t не может быть преобразован в целое число, поэтому использование NULL в качестве целого числа будет работать только условно, в зависимости от выбора, сделанного реализацией языка.

P.S. nullptr - это значение типа std​::​nullptr_­t. Если вам не нужно, чтобы ваша программа компилировалась до C ++ 11, вы всегда должны использовать nullptr вместо NULL.

C немного отличается (цитаты из проекта C11 N1548):

6.3.2.3 Язык / Преобразования / Другие операнды / Указатели

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

Таким образом, случай аналогичен публикации C ++ 11, то есть злоупотребление NULL работает условно в зависимости от выбора, сделанного реализацией языка.

Да, хотя в зависимости от реализации вам может потребоваться приведение. Но да, в остальном это 100% законно.

Хотя это действительно, действительно, очень плохой стиль (что и говорить?).

NULL является или был на самом деле не C ++, это C. Стандарт имеет, однако, как и для многих унаследованных C, имеет два предложения ([diff.null] и [ support.types.nullptr]), которые технически составляют NULL C ++. Это константа нулевого указателя, определяемая реализацией. Поэтому, даже если это плохой стиль, технически он такой же, как C ++, насколько это возможно.
Как указано в сноска, возможными реализациями могут быть 0 или 0L, но не (void*)0.

NULL, конечно, может (в стандарте это прямо не сказано, но это почти единственный вариант, оставшийся после 0 или 0L) быть nullptr. Такого почти никогда не бывает, но это вполне законная возможность.

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

В любом случае, у вас есть два возможных законных (т.е. компилятор не сломан) случая. Либо (реальный случай), NULL это что-то вроде 0 или 0L, тогда у вас есть "ноль или один" преобразований в целое число, и все готово.

Или NULL действительно nullptr. В этом случае у вас есть отдельное значение, которое гарантирует сравнение, а также четко определенные преобразования из целых чисел, но, к сожалению, не в целые числа. Однако он имеет четко определенное преобразование в bool (в результате получается false), а bool имеет четко определенное преобразование в целое число (в результате получается 0).

К сожалению, это две конверсии, поэтому она не находится в пределах "ноль или один", как указано в [conv]. Таким образом, если ваша реализация определяет NULL как nullptr, вам нужно будет добавить явное приведение, чтобы ваш код был правильным.

Из C часто задаваемых вопросов:

В: Что мне следует использовать, если NULL и 0 эквивалентны константам нулевого указателя?

A: Только в контексте указателя NULL и 0 эквивалентны. NULL не следует использовать, когда требуется другой тип 0, даже если он может работать, потому что это отправляет неправильное стилистическое сообщение. (Более того, ANSI допускает определение NULL как ((void *)0), что вообще не будет работать в контекстах без указателей.) В частности, не используйте NULL, когда требуется нулевой символ ASCII (NUL). Дайте собственное определение

http://c-faq.com/null/nullor0.html

Отказ от ответственности: я не знаю C ++. Мой ответ не предназначен для применения в контексте C ++

'\0' - это int со значением ноль, всего на 100% точно так же, как 0.

for (int k = 10; k > '\0'; k--) /* void */;
for (int k = 10; k > 0; k--) /* void */;

В контексте указателей 0 и NULL на 100% эквивалентны:

if (ptr) /* ... */;
if (ptr != NULL) /* ... */;
if (ptr != '\0') /* ... */;
if (ptr != 0) /* ... */;

все на 100% эквивалентны.

Примечание о ptr + NULL

Контекст ptr + NULL не контекста указателей. В языке C нет определения для добавления указателей; указатели и целые числа можно складывать (или вычитать). В ptr + NULL, если либо ptr, либо NULL является указателем, другой должен быть целым числом, поэтому ptr + NULL фактически (int)ptr + NULL или ptr + (int)NULL, и в зависимости от определений ptr и NULL можно ожидать нескольких вариантов поведения: все это работает , предупреждение о преобразовании между указателем и целым числом, сбой при компиляции, ...

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

Начиная с C ++ 11:

Ключевое слово nullptr обозначает литерал указателя. Это значение типа std :: nullptr_t. Существуют неявные преобразования из nullptr в значение нулевого указателя любого типа указателя и любого указателя на тип элемента. Подобные преобразования существуют для любой константы нулевого указателя, которая включает значения типа std::nullptr_t, а также макрос NULL.

http://Reference%20for%20documetation

Фактически, std :: nullptr_t - это тип литерала нулевого указателя, nullptr. Это отдельный тип, который сам по себе не является типом указателя или указателем на тип члена.

#include <cstddef>
#include <iostream>

void f(int* pi)
{
   std::cout << "Pointer to integer overload\n";
}

void f(double* pd)
{
   std::cout << "Pointer to double overload\n";
}

void f(std::nullptr_t nullp)
{
   std::cout << "null pointer overload\n";
}

int main()
{
    int* pi; double* pd;

    f(pi);
    f(pd);
    f(nullptr);  // would be ambiguous without void f(nullptr_t)
    // f(0);  // ambiguous call: all three functions are candidates
    // f(NULL); // ambiguous if NULL is an integral null pointer constant 
                // (as is the case in most implementations)
}

Вывод:

Pointer to integer overload
Pointer to double overload
null pointer overload