Wir haben jetzt C ++ 11 mit vielen neuen Funktionen. Eine interessante und verwirrende (zumindest für mich) ist die neue nullptr.

Nun, das böse Makro ist nicht mehr nötig NULL.

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

Trotzdem verstehe ich nicht, wie es nullptrfunktioniert. Zum Beispiel sagt der Wikipedia-Artikel :

C ++ 11 korrigiert dies, indem ein neues Schlüsselwort eingeführt wird , das als definierte Nullzeigerkonstante dient: nullptr. Es ist vom Typ nullptr_t , der implizit konvertierbar und mit jedem Zeigertyp oder Zeiger-zu- Element -Typ vergleichbar ist. Es ist nicht implizit konvertierbar oder mit integralen Typen vergleichbar, außer für bool.

Wie ist es ein Schlüsselwort und eine Instanz eines Typs?

Haben Sie auch ein anderes Beispiel (neben dem Wikipedia-Beispiel), bei dem nullptres dem guten alten überlegen ist 0?

Wie ist es ein Schlüsselwort und eine Instanz eines Typs?

Das ist nicht überraschend. Beide trueund falsesind Schlüsselwörter und als Literale haben sie einen Typ ( bool). nullptrist ein Zeiger wörtliche vom Typ std::nullptr_t, und es ist ein prvalue (die Adresse der es nicht mit nehmen kann &).

• 4.10Über die Zeigerkonvertierung heißt es, dass ein Wert vom Typ std::nullptr_teine Nullzeigerkonstante ist und dass eine integrale Nullzeigerkonstante in konvertiert werden kann std::nullptr_t. Die entgegengesetzte Richtung ist nicht erlaubt. Dies ermöglicht das Überladen einer Funktion sowohl für Zeiger als auch für Ganzzahlen und das Übergeben nullptrzur Auswahl der Zeigerversion. Bestehen NULLoder 0würde die intVersion verwirrend auswählen .

• Eine Umwandlung nullptr_tin einen integralen Typ benötigt a reinterpret_castund hat dieselbe Semantik wie eine Umwandlung (void*)0in einen integralen Typ (Mapping-Implementierung definiert). A reinterpret_castkann nicht nullptr_tin einen Zeigertyp konvertiert werden. Verlassen Sie sich nach Möglichkeit auf die implizite Konvertierung oder verwenden Sie diese static_cast.

• Der Standard verlangt , dass sizeof(nullptr_t)sei sizeof(void*).

Von nullptr: Ein typsicherer und eindeutiger Nullzeiger :

Das neue Schlüsselwort C ++ 09 nullptr bezeichnet eine rvalue-Konstante, die als universelles Nullzeigerliteral dient und das fehlerhafte und schwach typisierte Literal 0 und das berüchtigte NULL-Makro ersetzt. nullptr beendet damit mehr als 30 Jahre Verlegenheit, Zweideutigkeit und Fehler. In den folgenden Abschnitten wird die Nullptr-Funktion vorgestellt und gezeigt, wie sie die Probleme von NULL und 0 beheben kann.

Weitere Referenzen:

• WikiBooks mit Beispielcode.
• Hier bei Stack Overflow: Verwenden Sie NULL oder 0 (Null) für Zeiger in C ++?
• template
• Google-Gruppe: comp.lang.c ++. Moderiert - Compiler-Diskussion

Warum nullptr in C ++ 11? Was ist es? Warum reicht NULL nicht aus?

Der C ++ - Experte Alex Allain sagt es hier perfekt (meine Betonung ist fett gedruckt):

... stellen Sie sich vor, Sie haben die folgenden zwei Funktionsdeklarationen:

void func(int n); 
void func(char *s);

func( NULL ); // guess which function gets called?

Obwohl es so aussieht, als würde die zweite Funktion aufgerufen - Sie übergeben schließlich einen Zeiger -, ist es wirklich die erste Funktion, die aufgerufen wird! Das Problem ist, dass stattdessen die erste Version von func aufgerufen wird, da NULL 0 und 0 eine Ganzzahl ist. Dies ist die Art von Dingen, die zwar nicht immer passieren, aber wenn sie passieren, sind sie äußerst frustrierend und verwirrend. Wenn Sie die Details der Vorgänge nicht kennen, könnte dies wie ein Compiler-Fehler aussehen. Eine Sprachfunktion, die wie ein Compiler-Fehler aussieht, ist nicht das, was Sie wollen.

Geben Sie nullptr ein. In C ++ 11 ist nullptr ein neues Schlüsselwort, das zur Darstellung von NULL-Zeigern verwendet werden kann (und sollte!). Mit anderen Worten, wo immer Sie zuvor NULL geschrieben haben, sollten Sie stattdessen nullptr verwenden. Für Sie, den Programmierer , ist es nicht mehr klar (jeder weiß, was NULL bedeutet), aber für den Compiler ist es expliziter , dass nicht mehr überall Nullen verwendet werden, die eine besondere Bedeutung haben, wenn sie als Zeiger verwendet werden.

Allain beendet seinen Artikel mit:

Unabhängig davon lautet die Faustregel für C ++ 11 einfach, die Verwendung zu beginnen, nullptrwann immer Sie sie NULLin der Vergangenheit anderweitig verwendet hätten .

(Meine Worte):

Vergessen Sie nicht, dass dies nullptrein Objekt ist - eine Klasse. Es kann überall NULLdort verwendet werden, wo es zuvor verwendet wurde, aber wenn Sie seinen Typ aus irgendeinem Grund benötigen, kann es mit extrahiert decltype(nullptr)oder direkt als beschrieben werden std::nullptr_t, was einfach ein typedefvon ist decltype(nullptr).

Verweise:

1. Cprogramming.com: Bessere Typen in C ++ 11 - nullptr, Aufzählungsklassen (stark typisierte Aufzählungen) und cstdint
2. https://en.cppreference.com/w/cpp/language/decltype
3. https://en.cppreference.com/w/cpp/types/nullptr_t

Wenn Sie eine Funktion haben, die Zeiger auf mehr als einen Typ empfangen kann, ist der Aufruf mit nicht NULLeindeutig. Die Art und Weise, wie dies jetzt umgangen wird, ist sehr hackig, wenn man ein int akzeptiert und davon ausgeht, dass es ist NULL.

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); }
};

In C++11könnten Sie überladen, nullptr_tso dass ptr<T> p(42);dies eher ein Kompilierungsfehler als eine Laufzeit wäre assert.

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

nullptrkann keinem integralen Typ wie einem, intsondern nur einem Zeigertyp zugewiesen werden ; entweder ein eingebauter Zeigertyp wie int *ptroder ein intelligenter Zeiger wiestd::shared_ptr<T>

Ich glaube, dies ist eine wichtige Unterscheidung, da NULLimmer noch sowohl ein integraler Typ als auch ein Zeiger zugewiesen werden können, ebenso wie NULLein erweitertes Makro, 0das sowohl als Anfangswert für einen intals auch als Zeiger dienen kann.

Haben Sie auch ein anderes Beispiel (neben dem Wikipedia-Beispiel), bei nullptrdem die gute alte 0 überlegen ist?

Ja. Es ist auch ein (vereinfachtes) Beispiel aus der Praxis, das in unserem Produktionscode vorkommt. Es fiel nur auf, weil gcc beim Crosscompilieren auf eine Plattform mit unterschiedlicher Registerbreite eine Warnung ausgeben konnte (immer noch nicht sicher, warum, nur beim Crosscompilieren von x86_64 auf x86, warnt warning: converting to non-pointer type 'int' from NULL):

Betrachten Sie diesen Code (C ++ 03):

#include <iostream>

struct B {};

struct A
{
    operator B*() {return 0;}
    operator bool() {return true;}
};

int main()
{
    A a;
    B* pb = 0;
    typedef void* null_ptr_t;
    null_ptr_t null = 0;

    std::cout << "(a == pb): " << (a == pb) << std::endl;
    std::cout << "(a == 0): " << (a == 0) << std::endl; // no warning
    std::cout << "(a == NULL): " << (a == NULL) << std::endl; // warns sometimes
    std::cout << "(a == null): " << (a == null) << std::endl;
}

Es ergibt diese Ausgabe:

(a == pb): 1
(a == 0): 0
(a == NULL): 0
(a == null): 1

Nun, andere Sprachen haben reservierte Wörter, die Instanzen von Typen sind. Python zum Beispiel:

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

Dies ist eigentlich ein ziemlich enger Vergleich, da er Nonenormalerweise für etwas verwendet wird, das nicht initialisiert wurde, aber gleichzeitig Vergleiche wieNone == 0 falsch sind.

Andererseits würde in einfachem C NULL == 0wahres IIRC zurückgeben, da NULLes sich nur um ein Makro handelt, das 0 zurückgibt , was immer eine ungültige Adresse (AFAIK) ist.

Es ist ein Schlüsselwort, da der Standard es als solches spezifiziert. ;-) Nach dem neuesten öffentlichen Entwurf (n2914)

2.14.7 Zeigerliterale [lex.nullptr]

pointer-literal:
nullptr

Das Zeigerliteral ist das Schlüsselwort nullptr. Es ist ein Wert vom Typ std::nullptr_t.

Dies ist nützlich, da es nicht implizit in einen ganzzahligen Wert konvertiert wird.

Angenommen, Sie haben eine Funktion (f), die überladen ist, um sowohl int als auch char * zu übernehmen. Wenn Sie es vor C ++ 11 mit einem Nullzeiger aufrufen wollten und NULL (dh den Wert 0) verwendeten, würden Sie das für int überladene aufrufen:

void f(int);
void f(char*);

void g() 
{
  f(0); // Calls f(int).
  f(NULL); // Equals to f(0). Calls f(int).
}

Dies ist wahrscheinlich nicht das, was Sie wollten. C ++ 11 löst dies mit nullptr; Jetzt können Sie Folgendes schreiben:

void g()
{
  f(nullptr); //calls f(char*)
}

Lassen Sie mich zunächst eine Implementierung von ungekünstelt geben nullptr_t

struct nullptr_t 
{
    void operator&() const = delete;  // Can't take address of nullptr

    template<class T>
    inline operator T*() const { return 0; }

    template<class C, class T>
    inline operator T C::*() const { return 0; }
};

nullptr_t nullptr;

nullptrist ein subtiles Beispiel für die Rückgabetyp-Resolver-Sprache, mit der automatisch ein Nullzeiger des richtigen Typs abgeleitet wird, abhängig vom Typ der Instanz, der er zugewiesen wird.

int *ptr = nullptr;                // OK
void (C::*method_ptr)() = nullptr; // OK

• Wie oben beschrieben, wird beim nullptrZuweisen zu einem Ganzzahlzeiger eine intTypinstanziierung der Vorlagenkonvertierungsfunktion erstellt. Gleiches gilt auch für Methodenzeiger.
• Auf diese Weise erstellen wir durch die Nutzung der Vorlagenfunktionalität jedes Mal, wenn wir eine neue Typzuweisung durchführen, den entsprechenden Typ eines Nullzeigers.
• Da nullptres sich um ein ganzzahliges Literal mit dem Wert Null handelt, können Sie seine Adresse nicht verwenden, was wir durch Löschen von & operator erreicht haben.

Warum brauchen wir überhaupt nullptr?

• Sie sehen, traditionell NULLhat ein Problem damit wie folgt:

1️⃣ Implizite Konvertierung

char *str = NULL; // Implicit conversion from void * to char *
int i = NULL;     // OK, but `i` is not pointer type

2️⃣ Mehrdeutigkeit von Funktionsaufrufen

void func(int) {}
void func(int*){}
void func(bool){}

func(NULL);     // Which one to call?

• Die Kompilierung erzeugt den folgenden Fehler:

error: call to 'func' is ambiguous
    func(NULL);
    ^~~~
note: candidate function void func(bool){}
                              ^
note: candidate function void func(int*){}
                              ^
note: candidate function void func(int){}
                              ^
1 error generated.
compiler exit status 1

3️⃣ Konstruktorüberlastung

struct String
{
    String(uint32_t)    {   /* size of string */    }
    String(const char*) {       /* string */        }
};

String s1( NULL );
String s2( 5 );

• In solchen Fällen benötigen Sie eine explizite Besetzung (dh ,  String s((char*)0)).

0 war früher der einzige ganzzahlige Wert, der als umwandlungsfreier Initialisierer für Zeiger verwendet werden konnte: Sie können Zeiger ohne Umwandlung nicht mit anderen ganzzahligen Werten initialisieren. Sie können 0 als einen Consexpr-Singleton betrachten, der syntaktisch einem ganzzahligen Literal ähnlich ist. Es kann einen beliebigen Zeiger oder eine Ganzzahl initiieren. Aber überraschenderweise werden Sie feststellen, dass es keinen bestimmten Typ hat: Es ist ein int. Wie kommt es also, dass 0 Zeiger initialisieren kann und 1 nicht? Eine praktische Antwort war, dass wir ein Mittel zum Definieren des Zeiger-Nullwerts benötigen und die direkte implizite Konvertierung intin einen Zeiger fehleranfällig ist. So wurde 0 ein echtes Freak-Weirdo-Biest aus der prähistorischen Zeit. nullptrEs wurde vorgeschlagen, eine echte Singleton-Constexpr-Darstellung des Nullwerts zu sein, um Zeiger zu initialisieren. Es kann nicht verwendet werden, um Ganzzahlen direkt zu initialisieren, und beseitigt Unklarheiten, die mit der Definition NULLin Bezug auf 0 verbunden sind. Es nullptrkönnte als Bibliothek mit Standardsyntax definiert werden, wird jedoch semantisch als fehlende Kernkomponente angesehen. NULLwird jetzt zugunsten von abgelehnt nullptr, es sei denn, eine Bibliothek beschließt, es als zu definieren nullptr.

Hier ist der LLVM-Header.

// -*- C++ -*-
//===--------------------------- __nullptr --------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#ifndef _LIBCPP_NULLPTR
#define _LIBCPP_NULLPTR

#include <__config>

#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif

#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

#endif  // _LIBCPP_NULLPTR

(viel kann mit einem schnellen aufgedeckt werden grep -r /usr/include/*`)

Eine Sache, die herausspringt, ist die *Überlastung des Operators (die Rückgabe von 0 ist viel freundlicher als Segfaulting ...). Eine andere Sache ist es nicht kompatibel sieht mit Speichern einer Adresse überhaupt . Was im Vergleich dazu, wie es geht, Leere * zu schleudern und NULL-Ergebnisse als Sentinel-Werte an normale Zeiger zu übergeben, offensichtlich den Faktor "Niemals vergessen, es könnte eine Bombe sein" reduzieren würde.

NULL muss nicht 0 sein. Solange Sie immer NULL und niemals 0 verwenden, kann NULL ein beliebiger Wert sein. Angenommen, Sie programmieren einen von Neuman-Mikrocontroller mit flachem Speicher, dessen Interrupt vektoren bei 0 liegt. Wenn NULL 0 ist und etwas an einem NULL-Zeiger schreibt, stürzt der Mikrocontroller ab. Wenn NULL beispielsweise 1024 ist und bei 1024 eine reservierte Variable vorhanden ist, stürzt der Schreibvorgang nicht ab, und Sie können NULL-Zeigerzuweisungen im Programm erkennen. Dies ist auf PCs sinnlos, aber für Raumsonden, militärische oder medizinische Geräte ist es wichtig, nicht abzustürzen.