Qu'est-ce que c'est exactement nullptr?

Question

Nous avons maintenant C++11 avec de nombreuses nouvelles fonctionnalités. Un intéressant et déroutant (au moins pour moi) est le nouveau nullptr.

Eh bien, pas besoin de plus pour le méchant de la macro NULL.

int* x = nullptr;
myclass* obj = nullptr;

Pourtant, je ne reçois pas comment nullptr travaux. Par exemple, l' article de Wikipédia dit:

C++11 corrige ce par l'introduction d'un nouveau mot-clé à servir en tant que distingué pointeur null constante: nullptr. Il est de type nullptr_t, qui est implicitement convertible et comparable à n'importe quel type de pointeur ou un pointeur de type de membre. Il n'est pas implicitement convertible ou comparable à celle des types intégraux, sauf pour le type bool.

Comment est-il un mot clé et une instance d'un type?

Aussi, avez-vous un autre exemple (à côté de la Wikipédia) où nullptr est supérieur aux bonnes vieilles 0?

Answer 1

Comment est-il un mot clé et une instance d'un type?

Ce n'est pas surprenant. Les deux true et false sont des mots-clés et que des littéraux ils ont un type ( bool ). nullptr est un pointeur littéral de type std::nullptr_t, et c'est un prvalue (vous ne pouvez pas prendre l'adresse de l'aide d' &).

• 4.10 sur le pointeur de la conversion dit qu'un prvalue de type std::nullptr_t est un pointeur null constante, et qui intégrante de pointeur null constante peut être converti std::nullptr_t. La direction opposée n'est pas autorisé. Cela permet de surcharger une fonction pour les deux pointeurs et entiers, et en passant nullptr pour sélectionner le pointeur de la version. En passant NULL ou 0 serait de prêter à confusion, sélectionnez l' int version.

• Un casting de nullptr_t d'intégrante de type a besoin d'un reinterpret_cast, et a la même sémantique que l'un casting de (void*)0 pour un type intégral (cartographie de la mise en œuvre définies). Un reinterpret_cast ne peut pas convertir nullptr_t pour tout type de pointeur. Appuyer sur la conversion implicite si possible ou utiliser static_cast.

• La Norme exige que l' sizeof(nullptr_t) être sizeof(void*).

Answer 2

nullptr: Un coffre-fort et Clair de Pointeur Null

Le nouveau C++09 nullptr mot désigne une rvalue constante qui sert universelle de pointeur null littérale, en remplacement de la poussette et faiblement typé littérale 0, et l'infâme, NULL macro. nullptr met ainsi fin à plus de 30 ans de l'embarras, de l'ambiguïté, et des bugs. Les sections suivantes présentent les nullptr installation et de montrer comment il est possible de remédier à des maux de NULL ou 0.

---

Une autre bonne référence à WikiBooks: Plus de C++ Idiomes/nullptr
Avec des exemples de code.

---

Ici, à Stackoverflow:
Utilisez-vous la valeur NULL ou 0 (zéro) pour les pointeurs en C++?

---

D'autres références.

• template
• Google groupe: comp.lang.c++.moderated - compilateur discussion

Answer 3

Lorsque vous avez une fonction qui permet de recevoir des pointeurs à plus d'un type, puis de l'appel, il avec NULL est ambiguë, la façon dont cela est travaillé autour de maintenant est très hacky en acceptant un int et en supposant que c'est NULL (cas)

template <class T>
class ptr {
    T* p_;
    public:
        ptr(T* p) : p_(p) {}

        template <class U>
        ptr(U* u) : p_(dynamic_cast<T*>(u)) { }

        // Without this ptr<T> p(NULL) would be ambiguous
        ptr(int null) : p_(NULL)  { assert(null == NULL); }
};

En C++0x vous seriez en mesure de surcharge sur nullptr_t afin ptr<T> p(42); serait une erreur de compilation plutôt qu'un moment de l'exécution assert.

 ptr(std::nullptr_t) : p_(nullptr)  {  }

Answer 4

nullptr ne peut pas être attribué à un integral type comme un int, mais seulement un type pointer; soit intégré dans le type de pointeur comme int *ptr ou un pointeur intelligent comme std::shared_ptr<T>

Je crois que cette distinction est importante, car NULL peut encore être affecté à un integral type et pointer comme NULL est une macro élargi à d' 0 qui peut servir à la fois comme une valeur initiale pour un int ainsi qu'un pointer.

Answer 5

Bien, d'autres langues ont des mots réservés qui sont des instances de types. Python, par exemple:

>>> None = 5
  File "<stdin>", line 1
SyntaxError: assignment to None
>>> type(None)
<type 'NoneType'>

C'est en fait assez proche de comparaison, car None est généralement utilisé pour quelque chose qui n'a pas été initialisée, mais en même temps, des comparaisons telles que None == 0 sont faux.

D'autre part, dans la plaine, C, NULL == 0 serait de retour vrai IIRC, car NULL est juste une macro retourne 0, ce qui est toujours une adresse non valide (autant que je sache).