Come funziona l'implementazione di c ++ nullptr?

Sono curioso di sapere come nullptrfunziona. Gli standard N4659 e N4849 dicono:

1. deve avere tipo std::nullptr_t;
2. non puoi prendere il suo indirizzo;
3. può essere convertito direttamente in un puntatore e un puntatore in membro;
4. sizeof(std::nullptr_t) == sizeof(void*);
5. la sua conversione in boolè false;
6. il suo valore può essere convertito in tipo integrale in modo identico (void*)0, ma non al contrario;

Quindi è sostanzialmente una costante con lo stesso significato di (void*)0, ma ha un tipo diverso. Ho trovato l'implementazione di std::nullptr_tsul mio dispositivo ed è la seguente.

#ifdef _LIBCPP_HAS_NO_NULLPTR

_LIBCPP_BEGIN_NAMESPACE_STD

struct _LIBCPP_TEMPLATE_VIS nullptr_t
{
    void* __lx;

    struct __nat {int __for_bool_;};

    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR nullptr_t() : __lx(0) {}
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR nullptr_t(int __nat::*) : __lx(0) {}

    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR operator int __nat::*() const {return 0;}

    template <class _Tp>
        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
        operator _Tp* () const {return 0;}

    template <class _Tp, class _Up>
        _LIBCPP_INLINE_VISIBILITY
        operator _Tp _Up::* () const {return 0;}

    friend _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR bool operator==(nullptr_t, nullptr_t) {return true;}
    friend _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR bool operator!=(nullptr_t, nullptr_t) {return false;}
};

inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR nullptr_t __get_nullptr_t() {return nullptr_t(0);}

#define nullptr _VSTD::__get_nullptr_t()

_LIBCPP_END_NAMESPACE_STD

#else  // _LIBCPP_HAS_NO_NULLPTR

namespace std
{
    typedef decltype(nullptr) nullptr_t;
}

#endif  // _LIBCPP_HAS_NO_NULLPTR

Sono più interessato alla prima parte però. Sembra soddisfare i punti 1-5, ma non ho idea del perché abbia una sottoclasse __nat e tutto ciò che è collegato. Vorrei anche sapere perché non riesce nelle conversioni integrali.

struct nullptr_t2{
    void* __lx;
    struct __nat {int __for_bool_;};
     constexpr nullptr_t2() : __lx(0) {}
     constexpr nullptr_t2(int __nat::*) : __lx(0) {}
     constexpr operator int __nat::*() const {return 0;}
    template <class _Tp>
         constexpr
        operator _Tp* () const {return 0;}
    template <class _Tp, class _Up>
        operator _Tp _Up::* () const {return 0;}
    friend  constexpr bool operator==(nullptr_t2, nullptr_t2) {return true;}
    friend  constexpr bool operator!=(nullptr_t2, nullptr_t2) {return false;}
};
inline constexpr nullptr_t2 __get_nullptr_t2() {return nullptr_t2(0);}
#define nullptr2 __get_nullptr_t2()

int main(){
    long l  = reinterpret_cast<long>(nullptr);
    long l2 = reinterpret_cast<long>(nullptr2); // error: invalid type conversion
    bool b  = nullptr; // warning: implicit conversion
                       // edditor error: a value of type "std::nullptr_t" cannot be used to initialize an entity of type "bool"
    bool b2 = nullptr2;
    if (nullptr){}; // warning: implicit conversion
    if (nullptr2){};
};

Sono curioso di sapere come funziona nullptr.

Funziona nel modo più semplice possibile: da Fiat . Funziona perché lo standard C ++ dice che funziona e funziona come lo fa perché lo standard C ++ afferma che le implementazioni devono farlo funzionare in quel modo.

È importante riconoscere che è impossibile implementare std::nullptr_tusando le regole del linguaggio C ++. La conversione da una costante di puntatore null di tipo std::nullptr_tin un puntatore non è una conversione definita dall'utente. Ciò significa che puoi passare da una costante di puntatore null a un puntatore, quindi attraverso una conversione definita dall'utente in un altro tipo, il tutto in un'unica sequenza di conversione implicita.

Questo non è possibile se si implementa nullptr_tcome classe. Gli operatori di conversione rappresentano conversioni definite dall'utente e le regole implicite della sequenza di conversione di C ++ non consentono più di una conversione definita dall'utente in tale sequenza.

Quindi il codice che hai pubblicato è una buona approssimazione di std::nullptr_t, ma non è altro. Non è un'implementazione legittima del tipo. Questo probabilmente proveniva da una versione precedente del compilatore (lasciato per motivi di compatibilità con le versioni precedenti) prima che il compilatore fornisse il supporto adeguato per std::nullptr_t. Lo puoi vedere dal fatto che lo #defineè nullptr, mentre C ++ 11 dice che nullptrè una parola chiave , non una macro.

C ++ non può implementare std::nullptr_t, proprio come C ++ non può implementare into void*. Solo l'implementazione può implementare queste cose. Questo è ciò che lo rende un "tipo fondamentale"; fa parte della lingua .

il suo valore può essere convertito in tipo integrale in modo identico a (void *) 0, ma non al contrario;

Non esiste una conversione implicita da una costante puntatore null in tipi integrali. C'è una conversione da 0in un tipo integrale, ma è perché è lo zero letterale intero, che è ... un numero intero.

nullptr_tpuò essere eseguito il cast in un tipo intero (via reinterpret_cast), ma può essere implicitamente convertito solo in puntatori e in bool.