Warum sind NULL-Zeiger in C und C ++ unterschiedlich definiert?

In C NULList definiert als (void *)0in C ++ 0. Wieso ist es so? In CI kann man verstehen, dass Compiler möglicherweise Warnungen generieren , wenn sie NULLnicht typisiert werden (void *). Gibt es einen anderen Grund?

Zurück in C ++ 03 wurde ein Nullzeiger durch die ISO-Spezifikation (§4.10 / 1) als definiert

Eine Nullzeigerkonstante ist ein integraler Konstantenausdruck (5.19) rWert vom Integer-Typ, der zu Null ausgewertet wird.

Deshalb können Sie in C ++ schreiben

int* ptr = 0;

In C ist diese Regel ähnlich, aber etwas anders (§6.3.2.3 / 3):

Ein ganzzahliger Konstantenausdruck mit dem Wert 0 oder ein solcher Ausdruck, der in einen Typ umgewandelt wird void *, wird als Nullzeigerkonstante bezeichnet.55) Wenn eine Nullzeigerkonstante in einen Zeigertyp konvertiert wird, wird der resultierende Zeiger, der als Nullzeiger bezeichnet wird, garantiert Vergleiche ungleich einem Zeiger auf ein Objekt oder eine Funktion.

Folglich beides

int* ptr = 0;

und

int* ptr = (void *)0

sind legal. Ich vermute jedoch, dass die void*Besetzung hier ist, so dass Aussagen mögen

int x = NULL;

Erstellen Sie auf den meisten Systemen eine Compiler-Warnung. In C ++ wäre dies nicht legal, da Sie a ohne Umwandlung nicht implizit in einen void*anderen Zeigertyp konvertieren können . Dies ist beispielsweise illegal:

int* ptr = (void*)0; // Legal C, illegal C++

Dies führt jedoch zu Problemen aufgrund des Codes

int x = NULL;

ist legal C ++. Aus diesem Grund und der daraus resultierenden Verwirrung (und einem anderen Fall, der später gezeigt wird) gibt es seit C ++ 11 ein Schlüsselwort, nullptrdas einen Nullzeiger darstellt:

int* ptr = nullptr;

Dies hat keines der oben genannten Probleme.

Der andere Vorteil von nullptrüber 0 ist, dass es mit dem System vom Typ C ++ besser spielt. Angenommen, ich habe diese beiden Funktionen:

void DoSomething(int x);
void DoSomething(char* x);

Wenn ich anrufe

DoSomething(NULL);

Es ist gleichbedeutend mit

DoSomething(0);

das ruft DoSomething(int)statt der erwarteten DoSomething(char*). Mit nullptrkonnte ich jedoch schreiben

DoSomething(nullptr);

Und es wird die DoSomething(char*)Funktion wie erwartet aufrufen .

Angenommen, ich habe ein vector<Object*>und möchte jedes Element als Nullzeiger festlegen. Mit dem std::fillAlgorithmus könnte ich versuchen zu schreiben

std::fill(v.begin(), v.end(), NULL);

Dies wird jedoch nicht kompiliert, da das Vorlagensystem NULLals intund nicht als Zeiger behandelt wird. Um dies zu beheben, müsste ich schreiben

std::fill(v.begin(), v.end(), (Object*)NULL);

Dies ist hässlich und macht den Zweck des Vorlagensystems etwas zunichte. Um dies zu beheben, kann ich verwenden nullptr:

std::fill(v.begin(), v.end(), nullptr);

Und da nullptrbekannt ist, dass ein Typ einem Nullzeiger entspricht (speziell std::nullptr_t), wird dieser korrekt kompiliert.

Hoffe das hilft!

NULLErweitert in C auf eine implementierungsdefinierte "Nullzeigerkonstante". Eine Nullzeigerkonstante ist entweder ein ganzzahliger Konstantenausdruck mit dem Wert 0 oder ein solcher Ausdruck, in den umgewandelt wird void*. Eine C-Implementierung kann also NULLentweder als 0oder als definieren ((void*)0).

In C ++ unterscheiden sich die Regeln für Nullzeigerkonstanten. Insbesondere ((void*)0)handelt es sich nicht um eine C ++ - Nullzeigerkonstante, sodass eine C ++ - Implementierung diese nicht definieren NULLkann.

Die Sprache C wurde erstellt, um die Programmierung von Mikroprozessoren zu vereinfachen. Der AC-Zeiger wird verwendet, um die Adresse der Daten im Speicher zu speichern. Es war ein Weg erforderlich, um darzustellen, dass ein Zeiger keinen gültigen Wert hatte. Die Adresse Null wurde gewählt, da alle Mikroprozessoren diese Adresse zum Booten verwendeten. Da es für nichts anderes verwendet werden konnte, war Null eine gute Wahl, um einen Zeiger ohne gültigen Wert darzustellen. C ++ ist abwärtskompatibel mit C, daher hat es diese Konvention geerbt.

Die Anforderung, bei Verwendung als Zeiger Null zu setzen, ist nur ein neues Add-On. Spätere Generationen von C wollten mehr Genauigkeit (und hoffentlich weniger Fehler), damit sie die Syntax pedantischer angehen.