Início / coding / Perguntas / 78950164
Accepted
Mikhail T.
Asked: 2024-09-05 02:51:03 +0800 CST

Qual é a diferença entre passar NULL e nullptr para um parâmetro de modelo?

  • 772

Estou lidando com uma API razoavelmente uniforme fornecida por um fornecedor e gostaria de verificar -- e lidar -- com quaisquer falhas de forma unificada também. Para esse fim, escrevi o seguinte wrapper:

template <typename Func, typename... Args>
auto awrap(Func &func, Args&&... args)
{
    auto code = func(args...);

    if (code >= 0)
        return code;

    ... handle the error ...
};
...
awrap(handlepath, handle, path, NULL, 0, coll, NULL);

O comando acima compila bem com clang, mas o g++13 e o Microsoft VC++ reclamam dos dois argumentos NULL:

... error: invalid conversion from 'int' to 'const char*' [-fpermissive]
   87 |                 auto code = func(args...

Substituir os dois NULLs por nullptrresolve o problema, mas por que isso importa?

Provavelmente, o NULLé transformado em 0x0ou mesmo 0em algum lugar pelo pré-processador, mas a chamada original nunca levantou uma "sobrancelha". Usar NULL era perfeitamente adequado em:

handlepath(handle, path, NULL, 0, coll, NULL);

Por que isso é um problema (para alguns compiladores) quando usado em um wrapper?

ATUALIZAÇÃO : /usr/include/sys/_null.hno meu sistema FreeBSD tem o seguinte código:

#ifndef NULL

#if !defined(__cplusplus)
#define NULL    ((void *)0)
#else
#if __cplusplus >= 201103L
#define NULL    nullptr
#elif defined(__GNUG__) && defined(__GNUC__) && __GNUC__ >= 4
#define NULL    __null
#else
#if defined(__LP64__)
#define NULL    (0L)
#else
#define NULL    0
#endif  /* __LP64__ */
#endif  /* __GNUG__ */
#endif  /* !__cplusplus */

#endif

Então:

  1. para C, NULLé (void *)0;

  2. para clang++ NULLe nullptrsão a mesma coisa, enquanto para GNU pode não ser...

c++

2 respostas

  1. Best Answer

    Em muitas implementações, NULLé apenas um #definepara um literal inteiro 0 , por exemplo:

    #define NULL 0

    Você pode atribuir diretamente um literal 0 a qualquer ponteiro, e é por isso que passar NULLdiretamente para a função de destino funciona bem.

    Como você está passando NULLum parâmetro de modelo, esse parâmetro está sendo deduzido como tipo int, como diz a mensagem de erro.

    Nesta chamada:

    awrap(handlepath, handle, path, NULL, 0, coll, NULL);

    awrap()resolverá algo como isto:

    auto awrap(decltype(handlepath) &func, decltype(handle) arg1, decltype(path) arg2,
    int arg3, int arg4, decltype(coll) arg5, int arg6)
 // ^^^^^^^^                                 ^^^^^^^^
{
    auto code = func(arg1, arg2, arg3, arg4, arg5, arg6);
    //                    error: ^^^^       error: ^^^^
    ...
};

    Para atribuir uma intvariável a um ponteiro, você precisa de uma conversão de tipo explícita, que você não está usando.

    Enquanto nullptris do tipo nullptr_t, que também pode ser atribuído diretamente a qualquer ponteiro. Há apenas 1 valor possível de nullptr_t. Então, ao passar nullptrpara um parâmetro de template, esse parâmetro será deduzido como tipo nullptr_t. E o compilador sabe como atribuir a nullptr_ta um ponteiro.

    Nesta chamada:

    awrap(handlepath, handle, path, nullptr, 0, coll, nullptr);

    awrap()resolverá algo como isto:

    auto awrap(decltype(handlepath) &func, decltype(handle) arg1, decltype(path) arg2,
    nullptr_t arg3, int arg4, decltype(coll) arg5, nullptr_t arg6)
 // ^^^^^^^^^^^^^^                                 ^^^^^^^^^^^^^^
{
    auto code = func(arg1, arg2, arg3, arg4, arg5, arg6);
    //                       OK: ^^^^          OK: ^^^^
    ...
};

    Então, ao chamar seu modelo, você deve usar nullptr.

    Mas, se você quiser usá-lo NULL, você deve fazer a conversão de tipo como (char*)NULL(ou equivalente), ou qualquer outro tipo de ponteiro que o parâmetro esteja esperando, por exemplo:

    awrap(handlepath, handle, path, (char*)NULL, 0, coll, (char*)NULL);
    • 17

  2. NULLé uma macro que pode ser definida como nullptrou como um literal inteiro de valor zero (por exemplo, 0ou 0L). Qual deles é definido pela implementação, mas como apenas a última opção é válida em C e pré-C++11, as chances de ver a última são boas.

    nullptré um objeto de nullptr_t. Qualquer expressão desse tipo é sempre uma constante de ponteiro nulo , o que significa que pode ser convertida implicitamente em um valor de ponteiro nulo de qualquer tipo de ponteiro.

    Uma expressão inteira de valor zero, no entanto, nem sempre é uma constante de ponteiro nulo. Especificamente, apenas literais inteiros de valor nulo são constantes de ponteiro nulo que podem ser convertidas em tipos de ponteiro.

    Então, se você passar 0diretamente para uma função esperando um char*que funcione bem, o literal 0será uma constante de ponteiro nulo e poderá ser convertido para o tipo de ponteiro implicitamente, resultando em um valor de ponteiro nulo.

    Mas você está passando o literal para awrapcomo um tipo inteiro (por dedução). Quando você usa o argumento em , func(args...)ele ainda é uma expressão inteira com valor zero, mas não é um literal inteiro . Portanto, o argumento não é uma constante de ponteiro nulo e não pode ser convertido implicitamente para char*.

    Então, você não pode passar 0um parâmetro de ponteiro pelo wrapper porque você deve nomear o literal exatamente onde a conversão deve ser aplicada. E se você pode usar NULLé definido pela implementação. Funciona se NULLacontecer de ser definido como nullptr, mas não se for um literal inteiro de valor zero.

    Esse é um bom exemplo do porquê only nullptrdeve ser usado. O comportamento de conversão implícito de literais inteiros de valor zero existe apenas por razões históricas herdadas de C. Se a linguagem fosse projetada hoje, duvido que alguém adicionaria um caso especial tão estranho às conversões. Normalmente, as conversões possíveis são determinadas pelo tipo e categoria de valor das expressões. Esse é o único caso especial em que o valor e a construção gramatical afetam o comportamento de conversão.

    • 2

relate perguntas