Ist NULL immer falsch?

Kann man davon ausgehen NULL wird in C immer in false übersetzt?

void *somePtr = NULL;

if (!somePtr) {
  /* This will always be executed? */
}

Oder sollte eine explizite Prüfung gegen den Wert von erfolgen NULL gemacht sein?

Ja. NULL wird als falsch ausgewertet, da C jeden Nicht-Null-Wert als wahr und jeden Null-Wert als falsch betrachtet. NULL ist im Wesentlichen die zero Adresse und wird in Vergleichen als solche behandelt, und ich glaube, sie würde für die boolesche Prüfung zu einem Int befördert werden. Ich würde erwarten, dass Ihr Code für jeden lesbar ist, der mit C vertraut ist, obwohl ich die Überprüfung wahrscheinlich explizit machen würde.

In der C- und C++-Programmierung werden zwei Nullzeiger garantiert gleich verglichen; ANSI C garantiert, dass jeder Nullzeiger bei einem Vergleich mit einem Integer-Typ gleich 0 ist; Darüber hinaus ist das Makro NULL als Nullzeigerkonstante definiert, dh als Wert 0 (entweder als ganzzahliger Typ oder in einen Zeiger auf void konvertiert), sodass ein Nullzeiger mit NULL verglichen wird.

Ref: http://en.wikipedia.org/wiki/Null_pointer#Null_pointer

Die ‘C’-Sprache stammt aus einer Zeit, in der (void*)0 tatsächlich ein gültiger Zeiger sein könnte. Vor nicht allzu langer Zeit hatten die 8080- und Z80-Mikroprozessoren einen Interrupt-Vektor an der Adresse 0. Angesichts solcher Architekturentscheidungen konnte er nichts anderes tun, als eine Header-Datei den Wert NULL deklarieren zu lassen. Es gab einige längst vergessene Compiler, bei denen NULL nicht gleich (void*)0 war (0xffff war die nächste Alternative), wodurch Ihre if()-Anweisung ein undefiniertes Verhalten erhielt.

C++ hat dem gnädigerweise ein Ende gesetzt, ein Nullzeiger ist von 0 zuweisbar und gegen 0 testbar.

Es ist nie sicher, etwas anzunehmen.

Eine explizite Überprüfung ist auch klarer darüber, was Sie testen.

Ja (zumindest für jeden standardkonformen C-Compiler!)

Von dem comp.lang.c FAQ:

F: Ist der abgekürzte Zeigervergleich “if(p)” zum Testen auf Nicht-Null-Zeiger gültig? Was ist, wenn die interne Darstellung für Nullzeiger nicht Null ist?

A: Es ist immer gültig.

Meine Kopie von ISO/IEC 9899:TC3 (Committee Draft – 7. September 2007) sagt:

6.3 Konvertierungen

1 Mehrere Operatoren wandeln Operandenwerte automatisch von einem Typ in einen anderen um.

6.3.2.3 Zeiger

3 Ein ganzzahliger konstanter Ausdruck mit dem Wert 0 […] wird als Nullzeigerkonstante bezeichnet. Wenn eine Nullzeigerkonstante in einen Zeigertyp konvertiert wird, ist der resultierende Zeiger, der als Nullzeiger bezeichnet wird, garantiert ungleich mit einem Zeiger auf ein Objekt oder eine Funktion.

Bis jetzt, ptr!=0 ist wahr (1) für alle Nicht-Null ptraber es ist noch offen, wie sich zwei Nullzeiger vergleichen.

6.5.9 Gleichheitsoperatoren

5 […] Wenn ein Operand ein Zeiger und der andere eine Nullzeigerkonstante ist, wird die Nullzeigerkonstante in den Typ des Zeigers konvertiert.

6 Zwei Zeiger sind genau dann gleich, wenn beide Nullzeiger sind […]

Somit, ptr==0 ist 1 (und ptr!=0 0 ist), genau dann, wenn ptr ist ein Nullzeiger.

6.5.3.3 Unäre arithmetische Operatoren

5 Das Ergebnis des logischen Negationsoperators ! ist 0, wenn der Wert seines Operanden ungleich 0 ist, 1, wenn der Wert seines Operanden gleich 0 ist. Das Ergebnis hat den Typ int. Der Ausdruck !E entspricht (0==E).

Dasselbe gilt also für !ptr.

6.8.4.1 Die if-Anweisung

1 Der steuernde Ausdruck einer if-Anweisung muss einen Skalartyp haben.

2 In beiden Formen wird die erste Unteranweisung ausgeführt, wenn der Ausdruck ungleich 0 ist.

Beachten Sie, dass a skalarer Typ ist ein arithmetischer Typ oder ein Zeigertyp (siehe „6.2.5 Typen“, Abschnitt 21). Zusammengenommen haben wir:

• if (ptr) gelingt ⇔ ptr!=0 ist 1 ⇔ ptr ist kein Nullzeiger.
• if (!ptr) gelingt ⇔ ptr==0 ist 1 ⇔ ptr ist ein Nullzeiger.

Ja, if(!p) gültig ist und garantiert funktioniert.

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

https://port70.net/~nsz/c/c11/n1570.html#6.3.2.3p3

Das bedeutet, dass (void*)0 ist ein Nullzeiger. Es bedeutet auch, dass wenn p ist dann ein Zeiger p==0 ist äquivalent zu p==(void*)0.

Es bedeutet auch, dass wenn p ist also kein Nullzeiger p==(void*)0 wird zu bewerten 0.

So weit, ist es gut.

Die Konvertierung eines Nullzeigers in einen anderen Zeigertyp ergibt einen Nullzeiger dieses Typs. Beliebige zwei Nullzeiger sind gleich zu vergleichen.

http://port70.net/~nsz/c/c11/n1570.html#6.3.2.3p4

Beachten Sie, dass “Beliebige zwei Nullzeiger sind gleich zu vergleichen.” Das bedeutet, wenn p ist dann ein Nullzeiger p==0 wird als wahr bewertet, weil 0 werden befördert (void*)0 was ein Nullzeiger ist. Es bedeutet auch, dass kein Nicht-Null-Zeiger gleich einem Null-Zeiger sein kann.

Schauen wir uns den Negationsoperator an.

Das Ergebnis des logischen Negationsoperators ! ist 0, wenn der Wert seines Operanden ungleich 0 ist, 1, wenn der Wert seines Operanden gleich 0 ist. Das Ergebnis hat den Typ int. Der Ausdruck !E entspricht (0==E).

http://port70.net/~nsz/c/c11/n1570.html#6.5.3.3p5

Das sagt uns das !p ist das gleiche wie p==0 per Definition, was dasselbe ist wie p==(void*)0 wie oben erwähnt.

Und unter Berücksichtigung der Tatsache, dass alle Nullzeiger gleich sind, bedeutet dies Folgendes p==(void*)0 kann nur als wahr ausgewertet werden, wenn p ist ein Nullzeiger und nur dann falsch, wenn p ist kein Nullzeiger.

Also ja, if(!p) ist ein absolut sicherer Weg, um zu überprüfen, ob p ein Nullzeiger ist oder nicht.

NULL ist nur eine Präprozessordefinition. Es ist in stdio.h. Normalerweise würde nur eine verrückte Person es neu definieren, aber es ist möglich. Ein Beispiel:

#include <stdio.h>
#ifdef NULL
#undef NULL
#endif
#define NULL 1

void main()
{

        if (NULL)
                printf("NULL is true\n");
        else
                printf("NULL is false\n");
}

Dieser Code gibt “NULL ist wahr” aus. Probieren Sie es aus, wenn Sie mir nicht glauben. Ihr Compiler warnt Sie möglicherweise nicht einmal, dass Sie etwas Seltsames tun.