Вы используете NULL или 0 (ноль) для указателей в C++?

Вот мнение Страуструпа по этому поводу: Часто задаваемые вопросы о стилях и методах C++

In C++, the definition of NULL is 0, so there is only an aesthetic difference. I prefer to avoid macros, so I use 0. Another problem with NULL is that people sometimes mistakenly believe that it is different from 0 and/or not an integer. In pre-standard code, NULL was/is sometimes defined to something unsuitable and therefore had/has to be avoided. That's less common these days.

If you have to name the null pointer, call it nullptr; that's what it's called in C++11. Then, nullptr will be a keyword.

Тем не менее, не переживайте по мелочам.

Я думаю, что стандарт гарантирует, что NULL == 0, поэтому вы можете сделать то же самое. Я предпочитаю NULL, потому что он документирует ваше намерение.

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

char *p;

...

if (p) { ... }

не будет работать так, как вы ожидаете. Вы ДОЛЖНЫ написать

if (p != NULL) { ... }

Хотя я считаю, что в наши дни большинство компиляторов определяют NULL как 0, я все еще помню урок тех лет назад: NULL не обязательно равен 0.

Если я правильно помню, NULL определяется по-другому в заголовках, которые я использовал. Для C он определяется как (void *) 0, а для C++ - просто 0. Код выглядел примерно так:

#ifndef __cplusplus
#define NULL (void*)0
#else
#define NULL 0
#endif

Лично я все еще использую значение NULL для представления нулевых указателей, это явно указывает на то, что вы используете указатель, а не какой-то интегральный тип. Да, внутренне значение NULL по-прежнему равно 0, но оно не представлено как таковое.

Кроме того, я не полагаюсь на автоматическое преобразование целых чисел в логические значения, а сравниваю их явно.

Например, предпочитаю использовать:

if (pointer_value != NULL || integer_value == 0)

скорее, чем:

if (pointer_value || !integer_value)

Достаточно сказать, что все это исправлено в C++ 11, где можно просто использовать nullptr вместо NULL, а также nullptr_t, который является типом nullptr.

Я со Страуструпом в этом вопросе :-) Поскольку NULL не является частью языка, я предпочитаю использовать 0.

В основном личные предпочтения, хотя можно привести аргумент, что NULL делает совершенно очевидным, что объект является указателем, который в настоящее время ни на что не указывает, например

void *ptr = &something;
/* lots o' code */
ptr = NULL; // more obvious that it's a pointer and not being used

IIRC, стандарт не требует, чтобы NULL был равен 0, поэтому использование того, что определено в <stddef.h>, вероятно, лучше всего для вашего компилятора.

Другой аспект аргумента заключается в том, следует ли использовать логические сравнения (неявное приведение к типу bool) или явную проверку на NULL, но это также сводится к удобочитаемости.

Я всегда использую 0. Не по какой-то действительно продуманной причине, просто потому, что, когда я впервые изучал C++, я читал кое-что, что рекомендовало использовать 0, и я всегда делал это таким образом. Теоретически может возникнуть путаница в удобочитаемости, но на практике я ни разу не сталкивался с такой проблемой в тысячах человеко-часов и миллионах строк кода. Как говорит Страуструп, это просто личная эстетическая проблема, пока стандарт не станет nullptr.

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

Тем не менее, у меня нет проблем с использованием указателей как значений истинности самих по себе. Как и NULL, это укоренившаяся идиома.

C++ 09 добавит конструкцию nullptr, которая, на мой взгляд, давно назрела.

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

В новых проектах я помещаю это в заголовок проекта:

static const int nullptr = 0;

Теперь, когда появятся компиляторы, совместимые с C++ 0x, все, что мне нужно сделать, это удалить эту строку. Приятным преимуществом этого является то, что Visual Studio уже распознает nullptr как ключевое слово и соответствующим образом выделяет его.

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

Я всегда использую:

• NULL для указателей
• '\0' для символов
• 0.0 для поплавков и парных

где 0 подойдет. Это вопрос намерения сигнализировать. Тем не менее, я не анал об этом.

Есть несколько аргументов (один из которых относительно недавний), которые, как мне кажется, противоречат позиции Бьярна по этому поводу.

1. Документация о намерениях

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

2. Перегрузка указателя и int относительно редко

   Пример, который все цитируют:

    void foo(int*);
    void foo (int);
   
    void bar() {
      foo (NULL);  // Calls 'foo(int)'
    }
   

   Однако, по крайней мере, на мой взгляд, проблема с вышеизложенным не в том, что мы используем NULL для константы нулевого указателя, а в том, что у нас есть перегрузки foo(), которые принимают очень разные типы аргументов. Параметр также должен быть int, так как любой другой тип приведет к неоднозначному вызову и, таким образом, сгенерирует полезное предупреждение компилятора.

3. Инструменты анализа могут помочь СЕГОДНЯ!

   Даже в отсутствие C++ 0x сегодня доступны инструменты, которые проверяют, что NULL используется для указателей, а 0 используется для целочисленных типов.

4. C++ 11 будет иметь новый тип std::nullptr_t.

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

    #define NULL  nullptr
   

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

Обычно я использую 0. Мне не нравятся макросы, и нет никакой гарантии, что какой-то сторонний заголовок, который вы используете, не переопределяет NULL, чтобы он стал чем-то необычным.

Вы можете использовать объект nullptr, предложенный Скоттом Мейерсом и другими, пока C++ не получит ключевое слово nullptr:

const // It is a const object...
class nullptr_t 
{
public:
    template<class T>
    operator T*() const // convertible to any type of null non-member pointer...
    { return 0; }

    template<class C, class T>
    operator T C::*() const   // or any type of null member pointer...
    { return 0; }

private:
    void operator&() const;  // Can't take address of nullptr

} nullptr = {};

Google "nullptr" для получения дополнительной информации.

Я стараюсь избежать ответа на этот вопрос, используя ссылки на C++, где это возможно. Скорее, чем

void foo(const Bar* pBar) { ... }

вы часто можете написать

void foo(const Bar& bar) { ... }

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

Кто-то сказал мне однажды ... Я собираюсь переопределить NULL на 69. С тех пор я не использую его: P

Это делает ваш код довольно уязвимым.

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

Не все в стандарте идеально. Макрос NULL - это константа нулевого указателя C++, определяемая реализацией, не полностью совместимая с макросом C NULL, который, помимо неявного скрытия типа, преобразует его в бесполезный и подверженный ошибкам инструмент.

NULL действует не как нулевой указатель, а как литерал O / OL.

Скажите, что следующий пример не сбивает с толку:

void foo(char *); 
void foo(int); 
foo(NULL); // calls int version instead of pointer version! 

Из-за всего этого в новом стандарте появляется std :: nullptr_t

Если вы не хотите ждать выхода нового стандарта и хотите использовать nullptr, используйте хотя бы достойный, например, предложенный Мейерсом (см. Комментарий jon.h).

Странно, никто, в том числе Страуструп, не упомянул об этом. Говоря много о стандартах и ​​эстетике, никто не заметил, что это опасный для использования 0 вместо NULL, например, в списке переменных аргументов в архитектуре, где sizeof(int) != sizeof(void*). Как и Stroustroup, я предпочитаю 0 по эстетическим соображениям, но нужно быть осторожным, чтобы не использовать его там, где его тип может быть неоднозначным.

    cerr << sizeof(0) << endl;
    cerr << sizeof(NULL) << endl;
    cerr << sizeof(void*) << endl;

    ============
    On a 64-bit gcc RHEL platform you get:
    4
    8
    8
    ================

Мораль истории. Вы должны использовать NULL, когда имеете дело с указателями.

1) Он объявляет ваше намерение (не заставляйте меня перебирать весь ваш код, пытаясь выяснить, является ли переменная указателем или каким-то числовым типом).

2) В некоторых вызовах API, ожидающих переменных аргументов, они будут использовать NULL-указатель, чтобы указать конец списка аргументов. В этом случае использование «0» вместо NULL может вызвать проблемы. На 64-битной платформе вызову va_arg требуется 64-битный указатель, но вы будете передавать только 32-битное целое число. Мне кажется, что вы полагаетесь на то, что остальные 32 бита будут обнулены для вас? Я видел некоторые компиляторы (например, Intel icpc), которые не так хороши, и это приводило к ошибкам во время выполнения.

Установить указатель на 0 не так-то просто. Особенно, если вы используете язык, отличный от C++. Это включает C, а также Javascript.

Недавно я использовал такой код:

virtual void DrawTo(BITMAP *buffer) =0;

для чистой виртуальной функции впервые. Я думал, что это какой-то волшебный джиберджаш на неделю. Когда я понял, что это просто установка указателя функции на null (поскольку виртуальные функции в большинстве случаев являются просто указателями на функции для C++), я ударил себя.

virtual void DrawTo(BITMAP *buffer) =null;

был бы менее запутанным, чем эта разбойница без должного расстояния для моих новых глаз. На самом деле, мне интересно, почему C++ не использует null в нижнем регистре так же, как сейчас он использует нижний регистр false и true.

Использование 0 или NULL будет иметь тот же эффект.

Однако это не означает, что они оба являются хорошими практиками программирования. Учитывая, что нет никакой разницы в производительности, выбор варианта с низким уровнем осведомленности вместо агностической / абстрактной альтернативы является плохой практикой программирования. Помогите читателям вашего кода понять ваш мыслительный процесс.

NULL, 0, 0.0, '\ 0', 0x00 и whatelse все переводятся в одно и то же, но являются разными логическими объектами в вашей программе. Их следует использовать как таковые. NULL - это указатель, 0 - количество, 0x0 - значение, биты которого интересны и т. д. Вы не стали бы назначать '\ 0' указателю, компилируется он или нет.

Я знаю, что некоторые сообщества поощряют демонстрацию глубоких знаний об окружающей среде, нарушая условия окружающей среды. Однако ответственные программисты создают поддерживаемый код и не допускают подобных действий в свой код.

Ну, я выступаю за то, чтобы вообще не использовать указатели 0 или NULL, когда это возможно.

Их использование рано или поздно приведет к ошибкам сегментации в вашем коде. По моему опыту, это, и указатели в gereral - один из самых больших источников ошибок в C++.

кроме того, это приводит к появлению операторов if-not-null по всему вашему коду. Намного лучше, если вы всегда можете положиться на действительное состояние.

Почти всегда есть лучшая альтернатива.

Я бы сказал, что история заговорила, и те, кто выступал за использование 0 (ноль), были неправы (включая Бьярна Страуструпа). Аргументами в пользу 0 были в основном эстетика и «личные предпочтения».

После создания C++ 11 с его новым типом nullptr некоторые компиляторы начали жаловаться (с параметрами по умолчанию) на передачу 0 функциям с аргументами указателя, поскольку 0 не является указателем.

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

И если вам нужно прямо сейчас написать новый код для стандарта C++ 03 (и вы не можете использовать nullptr), вам действительно стоит просто использовать NULL. Это упростит вам обновление в будущем.