Você usa NULL ou 0 (zero) para ponteiros em C ++?

Nos primeiros dias do C ++, quando ele era aparafusado em cima de C, não era possível usar NULL como definido (void*)0. Você não pode atribuir NULL a nenhum ponteiro além de void*, o que o tornou meio inútil. Naqueles dias, era aceito que você usasse 0(zero) para ponteiros nulos.

Até hoje, continuei usando zero como ponteiro nulo, mas aqueles que estão à minha volta insistem em usá-lo NULL. Pessoalmente, não vejo nenhum benefício em atribuir um nome ( NULL) a um valor existente - e como também gosto de testar ponteiros como valores verdadeiros:

if (p && !q)
  do_something();

então, usar zero faz mais sentido (como se você usar NULL, não é possível usar logicamente p && !q- você precisa comparar explicitamente NULL, a menos que assuma que NULLé zero; nesse caso, por que usar NULL).

Existe alguma razão objetiva para preferir zero a NULL (ou vice-versa), ou é apenas preferência pessoal?

Editar: devo adicionar (e pretendia dizer originalmente) que, com RAII e exceções, raramente uso ponteiros zero / NULL, mas às vezes você ainda precisa deles.

Aqui está a opinião de Stroustrup sobre isso: Perguntas frequentes sobre estilo e técnica em C ++

Em C ++, a definição de NULLé 0, então há apenas uma diferença estética. Eu prefiro evitar macros, então uso 0. Outro problema NULLé que às vezes as pessoas acreditam erroneamente que é diferente de 0 e / ou não é um número inteiro. No código pré-padrão, NULLfoi / às vezes definido como algo inadequado e, portanto, teve / deve ser evitado. Isso é menos comum hoje em dia.

Se você precisar nomear o ponteiro nulo, chame-o nullptr; é assim que é chamado em C ++ 11. Então, nullptrserá uma palavra-chave.

Dito isto, não se preocupe com as pequenas coisas.

Existem alguns argumentos (um dos quais é relativamente recente) que acredito contradizerem a posição de Bjarne sobre isso.

1. Documentação de intenção

O uso NULLpermite pesquisas sobre seu uso e também destaca que o desenvolvedor queria usar um NULLponteiro, independentemente de ele estar sendo interpretado NULLou não pelo compilador .

2. Sobrecarga de ponteiro e 'int' é relativamente rara

O exemplo que todo mundo cita é:

void foo(int*);
void foo (int);

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

No entanto, pelo menos na minha opinião, o problema com o exposto acima não é que estamos usando NULL para a constante de ponteiro nulo, é que temos sobrecargas de 'foo' que usam tipos de argumentos muito diferentes. O parâmetro também deve ser um int, pois qualquer outro tipo resultará em uma chamada ambígua e, portanto, gerará um aviso útil do compilador.

3. As ferramentas de análise podem ajudar HOJE!

Mesmo na ausência de C ++ 0x, existem ferramentas disponíveis hoje que verificam se NULLestá sendo usado para ponteiros e se 0está sendo usado para tipos integrais.

4. O C ++ 11 terá um novo std::nullptr_ttipo.

Este é o argumento mais recente da tabela. O problema de 0e NULLestá sendo tratado ativamente no C ++ 0x, e você pode garantir que, para cada implementação que forneça NULL, a primeira coisa que eles farão é:

#define NULL  nullptr

Para aqueles que usam NULLem vez de 0, a mudança será uma melhoria no tipo de segurança com pouco ou nenhum esforço - se alguma coisa ele também pode pegar alguns bugs onde eles utilizados NULLpara 0. Para quem usa 0hoje ... bem ... espero que eles tenham um bom conhecimento de expressões regulares ...

Use NULL. NULL mostra sua intenção. O fato de ser 0 é um detalhe de implementação que não deve importar.

Eu sempre uso:

• NULL para ponteiros
• '\0' para caracteres
• 0.0 para carros alegóricos e duplos

onde 0 faria bem. É uma questão de sinalizar intenção. Dito isto, eu não sou anal sobre isso.

Parei de usar NULL em favor de 0 há muito tempo (assim como a maioria das outras macros). Fiz isso não apenas porque queria evitar o máximo possível de macros, mas também porque NULL parece ter sido superutilizado no código C e C ++. Parece ser usado sempre que um valor 0 é necessário, não apenas para ponteiros.

Em novos projetos, coloquei isso no cabeçalho do projeto:

static const int nullptr = 0;

Agora, quando chegam os compiladores compatíveis com C ++ 0x, tudo o que preciso fazer é remover essa linha. Uma boa vantagem disso é que o Visual Studio já reconhece o nullptr como uma palavra-chave e o destaca adequadamente.

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

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

A moral da história. Você deve usar NULL quando estiver lidando com ponteiros.

1) Declara sua intenção (não me faça pesquisar em todo o seu código tentando descobrir se uma variável é um ponteiro ou algum tipo numérico).

2) Em determinadas chamadas de API que esperam argumentos variáveis, eles usarão um ponteiro NULL para indicar o final da lista de argumentos. Nesse caso, usar um '0' em vez de NULL pode causar problemas. Em uma plataforma de 64 bits, a chamada va_arg deseja um ponteiro de 64 bits, mas você passará apenas um número inteiro de 32 bits. Parece-me que você está confiando nos outros 32 bits para ser zerado para você? Eu vi alguns compiladores (por exemplo, icpc da Intel) que não são tão gentis - e isso resultou em erros de tempo de execução.

Se bem me lembro, NULL é definido de maneira diferente nos cabeçalhos que usei. Para C, é definido como (void *) 0, e para C ++, é definido como apenas 0. O código se parecia com:

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

Pessoalmente, ainda uso o valor NULL para representar ponteiros nulos, deixando explícito que você está usando um ponteiro em vez de algum tipo integral. Sim internamente, o valor NULL ainda é 0, mas não é representado como tal.

Além disso, não confio na conversão automática de números inteiros em valores booleanos, mas os comparo explicitamente.

Por exemplo, prefira usar:

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

ao invés de:

if (pointer_value || !integer_value)

Basta dizer que tudo isso é remediado no C ++ 11, onde se pode simplesmente usar em nullptrvez de NULL, e também nullptr_tesse é o tipo de a nullptr.

Eu diria que a história falou e aqueles que argumentaram a favor do uso de 0 (zero) estavam errados (incluindo Bjarne Stroustrup). Os argumentos a favor de 0 eram principalmente estética e "preferência pessoal".

Após a criação do C ++ 11, com seu novo tipo nullptr, alguns compiladores começaram a reclamar (com parâmetros padrão) sobre a passagem de 0 para funções com argumentos de ponteiro, porque 0 não é um ponteiro.

Se o código tivesse sido escrito usando NULL, uma simples pesquisa e substituição poderia ter sido realizada através da base de código para torná-lo nullptr. Se você está preso ao código escrito usando a opção 0 como ponteiro, é muito mais entediante atualizá-lo.

E se você tiver que escrever um novo código agora no padrão C ++ 03 (e não puder usar o nullptr), deverá realmente usar o NULL. Isso facilitará muito a atualização no futuro.

Eu normalmente uso 0. Não gosto de macros e não há garantia de que algum cabeçalho de terceiros que você está usando não redefina NULL para ser algo estranho.

Você pode usar um objeto nullptr como proposto por Scott Meyers e outros até que o C ++ obtenha uma palavra-chave 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" para mais informações.

Certa vez, trabalhei em uma máquina em que 0 era um endereço válido e NULL foi definido como um valor octal especial. Nessa máquina (0! = NULL), código como

char *p;

...

if (p) { ... }

não funcionaria como você espera. Você teve que escrever

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

Embora eu acredite que a maioria dos compiladores defina NULL como 0 atualmente, ainda me lembro da lição daqueles anos atrás: NULL não é necessariamente 0.

Eu acho que o padrão garante que NULL == 0, então você pode fazer qualquer um. Prefiro NULL porque documenta sua intenção.

Usar 0 ou NULL terá o mesmo efeito.

No entanto, isso não significa que ambas sejam boas práticas de programação. Dado que não há diferença no desempenho, a escolha de uma opção com reconhecimento de baixo nível sobre uma alternativa agnóstica / abstrata é uma prática ruim de programação. Ajude os leitores do seu código a entender seu processo de pensamento .

NULL, 0, 0,0, '\ 0', 0x00 e tudo o mais são traduzidos para a mesma coisa, mas são entidades lógicas diferentes no seu programa. Eles devem ser usados ​​como tal. NULL é um ponteiro, 0 é quantidade, 0x0 é um valor cujos bits são interessantes etc. Você não atribuiria '\ 0' a um ponteiro, seja ele compilado ou não.

Sei que algumas comunidades incentivam a demonstrar conhecimento profundo de um ambiente, quebrando os contratos do ambiente. Programadores responsáveis, no entanto, criam código sustentável e mantêm essas práticas fora de seu código.

Estranho, ninguém, incluindo Stroustroup mencionou isso. Ao falar muito sobre padrões e estética, ninguém percebeu que é perigoso usá-lo 0em NULLseu lugar, por exemplo, na lista de argumentos variáveis ​​na arquitetura em que sizeof(int) != sizeof(void*). Como Stroustroup, prefiro 0por razões estéticas, mas é preciso ter cuidado para não usá-lo onde seu tipo possa ser ambíguo.

Eu tento evitar toda a pergunta usando referências C ++ sempre que possível. Ao invés de

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

você pode frequentemente escrever

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

Claro, isso nem sempre funciona; mas ponteiros nulos podem ser usados ​​em excesso.

Estou com o Stroustrup neste :-) Como o NULL não faz parte do idioma, prefiro usar 0.

Preferência principalmente pessoal, embora se possa argumentar que NULL torna bastante óbvio que o objeto é um ponteiro que atualmente não aponta para nada, por exemplo

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

IIRC, o padrão não exige que NULL seja 0, portanto, usar o que estiver definido em <stddef.h> provavelmente é o melhor para o seu compilador.

Outra faceta do argumento é se você deve usar comparações lógicas (conversão implícita para bool) ou verificação de explicitação contra NULL, mas isso também se resume à legibilidade.

Prefiro usar NULL, pois deixa claro que sua intenção é que o valor represente um ponteiro e não um valor aritmético. O fato de ser uma macro é lamentável, mas, uma vez que é tão amplamente arraigado, há pouco perigo (a menos que alguém faça algo realmente tímido). Eu gostaria que fosse uma palavra-chave desde o início, mas o que você pode fazer?

Dito isto, não tenho nenhum problema em usar ponteiros como valores de verdade em si mesmos. Assim como no NULL, é um idioma arraigado.

O C ++ 09 adicionará a construção nullptr que acho que está muito atrasada.

Eu sempre uso 0. Não por qualquer motivo real, apenas porque quando eu estava aprendendo C ++, eu li algo que recomendava o uso de 0 e sempre fiz dessa maneira. Em teoria, poderia haver um problema de confusão na legibilidade, mas, na prática, nunca encontrei esse problema em milhares de horas-homem e milhões de linhas de código. Como Stroustrup diz, é realmente apenas uma questão estética pessoal até que o padrão se torne nulo.

Alguém me disse uma vez ... Vou redefinir NULL para 69. Desde então, não o uso: P

Isso torna seu código bastante vulnerável.

Editar:

Nem tudo no padrão é perfeito. A macro NULL é uma constante de ponteiro nulo C ++ definida pela implementação que não é totalmente compatível com a macro C NULL, que além do tipo oculto implícito a converte em uma ferramenta inútil e propensa a erros.

NULL não se comporta como um ponteiro nulo, mas como um literal de O / OL.

Diga-me que o próximo exemplo não é confuso:

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

É por tudo isso, no novo padrão aparece std :: nullptr_t

Se você não quiser esperar pelo novo padrão e quiser usar um nullptr, use pelo menos um decente como o proposto por Meyers (consulte o comentário jon.h).

Bem, eu argumento por não usar ponteiros 0 ou NULL, sempre que possível.

Usá-los mais cedo ou mais tarde levará a falhas de segmentação no seu código. Na minha experiência, isso e ponteiros em gereral é uma das maiores fontes de bugs em C ++

Além disso, leva a instruções "if-not-null" em todo o seu código. Muito melhor se você puder confiar sempre em um estado válido.

Quase sempre há uma alternativa melhor.

Definir um ponteiro para 0 simplesmente não é tão claro. Especialmente se você vir uma linguagem diferente de C ++. Isso inclui C e Javascript.

Recentemente delt com algum código como este:

virtual void DrawTo(BITMAP *buffer) =0;

pela função virtual pura pela primeira vez. Eu pensei que fosse algum jiberjash mágico por uma semana. Quando percebi que estava basicamente configurando o ponteiro de função para a null(como funções virtuais são apenas ponteiros de função na maioria dos casos para C ++), me chutei.

virtual void DrawTo(BITMAP *buffer) =null;

teria sido menos confuso do que aquela conversa sem espaçamento adequado para os meus novos olhos. Na verdade, estou me perguntando por que o C ++ não emprega letras minúsculas, nullassim como emprega letras minúsculas falsas e verdadeiras agora.