Die Nulladresse in C

Nulladreßkonstanten

Das Literal »0« ist eine Nulladreßkonstante.

Initialisierungen und Zuweisungen

Ein Zeiger kann mit einer Nulladresse initialisiert werden. Einem Zeiger kann eine Nulladresse zugewiesen werden.

Der Zeiger enthält danach eine Nulladresse.

In dem folgenden Programm enthält der Zeiger »p« eine Nulladresse.

main.c

int main( void ){ int const * const p = 0; /**/ }

Auch in dem folgenden Programm enthält der Zeiger »p« eine Nulladresse.

main.c

int main( void ){ int const * p; p = 0; /**/ }

Wahrheitskontexte

Ein Adreßausdruck kann in einem Wahrheitskontext ausgewertet werden. Er ergibt genau dann „falsch“, wenn sein Wert die Nulladresse ist.

Die Adresse eines Objekts ist nie die Nulladresse.

main.c

#include <stdio.h>
int main( void )
{ int i = 27; 
  int const * p = 0;
  int const * q = &i;
  printf( "%sNull\n",( p ? "nicht " : "" )); 
  printf( "%sNull\n",( q ? "nicht " : "" )); }

stdout

Null
nicht Null

main.c

#include <stdio.h>
int main( void )
{ int i = 27; 
  int const * p = 0;
  int const * q = &i;
  printf( "%d\n", !p ); 
  printf( "%d\n", !q ); }

stdout

1
0

main.c

#include <stdio.h>
int main( void )
{ int i = 27; 
  int const * p = 0;
  int const * q = &i;
  if( p )printf( "p\n" ); 
  if( q )printf( "q\n" ); }

stdout

main.c

#include <stdio.h>
int main( void )
{ int i = 27; 
  int const * p = 0;
  int const * q = &i;
  while( p )printf( "p\n" ); 
  while( q )printf( "q\n" ); }

stdout

q
q
q

…

Vergleiche

Eine Nulladresse kann mit anderen Adressen eines verträglichen Typs verglichen werden, das Ergebnis des Vergleichs ist 1 genau dann, wenn die andere Adresse eine Nulladresse ist.

main.c

#include <stdio.h>
int main( void )
{ int i = 27; 
  int const * p = 0;
  int const * q = &i;
  printf( "%d\n", p == p ); 
  printf( "%d\n", p == q ); }

stdout

1
0

Quelle *

“If a null pointer constant is converted to a pointer type, the resulting pointer, called a null pointer, is guaranteed to compare unequal to a pointer to any object or function.”, C 2015, 6.3.2.3p3

Vergleiche mit der Nulladreßkonstanten

Eine Nulladreßkonstante kann mit Adressen verglichen werden, das Ergebnis des Vergleichs ist 1 genau dann, wenn die andere Adresse eine Nulladresse ist.

main.c

#include <stdio.h>
int main( void )
{ int i = 27; 
  int const * p = 0;
  int const * q = &i;
  printf( "%d\n", 0 == p ); 
  printf( "%d\n", 0 == q ); }

stdout

1
0

Dereferenzierung

Die Nulladresse ist keine Adresse eines Objektes. Sie hat keinen Referenten. Daher darf sie nicht dereferenziert werden.

main.c

#include <stdio.h>
int main( void )
{ int const * p = 0;
  printf( "%d\n", *p ); }

→ Undefiniertes Verhalten

Eine Nulladresse darf nicht dereferenziert werden.

Parameter ohne Nullsicherheit

So wie die Dereferenzierung einer Nulladresse zu undefiniertem Verhalten führt, kann auch die Übergabe einer Nulladresse als Argument zu undefiniertem Verhalten führen.

Wir nennen einen Parameter, bei dem der Wert 0 zu nicht zu undefiniertem Verhalten führt, auch nullsicher. Einen Parameter, der nicht nullsicher ist, nennen wir auch nullunsicher. In Texten, die für die Allgemeinheit verständlich sein sollen, sind aber Ausdrücke wie „darf 0 sein“ oder „darf nicht 0 sein“ verständlicher.

Es sollte für Paramter stets dokumentiert werden, wenn einige Argumentwerte zu undefiniertem Verhalten führen.

main.c

#include <stdio.h>

/** @brief Gibt int-Referenten aus
@param p Adresse eines int-Referenten, darf nicht 0 sein
@details Diese Funktion gibt den Referenten einer int-Adresse aus. */

void print( int const * const p )
{ printf( "%d\n", *p ); }

Dokumentation

void print( int const * const  p )
Gibt int-Referenten aus.
Parameter
p Adresse eines int-Referenten, darf nicht 0 sein
Diese Funktion gibt den Referenten einer int-Adresse aus.

Um die Dokumentation zu erzeugen (unter Windows ): 1.) Projektordner anlegen, 2.) Doxygen aus Internet kopieren, 3.) Doxygen mit »-g« aufrufen, um »Doxyfile« zu generieren, 3.) in »Doxyfile«: »EXTRACT_ALL = YES« und »OUTPUT_LANGUAGE = German« einstellen, 4.) Quelldatei »main.c« in Projektordner kopieren, 5.) Doxygen ohne »-g« aufrufen, um Dokumentation zu generieren, 6.) Datei »html\main_8c.html« in Web-Browser betrachten.

Damit die Programme kurz und übersichtlich bleiben wird in diesem Kurs Dokumentation zu Funktionen nicht immer geschrieben. In der Praxis sollten aber alle Funktionen eines Programm, das längere Zeit wartbar bleiben soll, dokumentiert sein.

Wenn Nullunsicherheit dokumentiert wurde, liegt die Verantwortung nun beim Benutzer der Funktion. Dieser ist nun dafür verantwortlich, daß die Funktion nicht mit »0« aufgerufen wird. Es gilt nicht als Fehler einer Funktion, wenn ein Funktionsaufruf mit dem Argument »0« zu undefiniertem Verhalten führt, falls die Tatsache, daß dies so ist, dokumentiert wurde.

Parameter mit Nullsicherheit

Eine Funktion kann aber oft auch so geschrieben werden, daß sie auch dann definiertes Verhalten hat, wenn der Argumentwert »0« übergeben wird.

main.c

#include <stdio.h>

/** @brief Gibt int-Referenten aus
@param p Adresse eines int-Referenten oder 0
@details Diese Funktion gibt den Referenten einer int-Adresse aus,
falls diese nicht 0 ist. */

void print( int const * const p )
{ if( p )printf( "%d\n", *p ); }

In diesem Fall kann die Funktion mit dem Argumentwert 0 aufgerufen werden, ohne undefiniertes Verhalten befürchten zu müssen.

Das folgende Programm zeigt nun den Aufruf einer Funktion mit dem Wert 0 für einen Adreßparameter.

main.c

#include <stdio.h>
void print( int const * const p )
{ if( p )printf( "%d\n", *p ); }
int main( void )
{ int i = 27; 
  print( &i ); 
  print(  0 ); }

stdout

Der Autor einer Funktion sollte das Verhalten einer Funktion für jeden möglichen Wert eines Parameters dokumentieren.

Die Nulladresse als Ergebnis

Eine Funktion, deren Rückgabetyp ein Adreßtyp ist, kann eine Nulladresse als Ergebnis zurückgeben.

Ob dies bei einer Funktion vorkommen kann, und was es dann bedeutet, hängt von der Funktion ab und muß durch die Dokumentation der Funktion beschrieben werden.

Beispielsweise könnte eine Funktion, die eigentlich eine Adresse eines Objekts zurückgeben soll, eine Nulladresse zurückgeben, wenn sie ihre Aufgabe aus irgendeinem Grund nicht erfüllen konnte. Der Aufrufer der Funktion kann dann daran erkennen, daß die aufgerufene Funktion ihre Aufgabe nicht erfüllen konnte.

main.c

#include <stdio.h>

/** @brief Gibt den Wert des Arguments zurück.
@param p Ein int-Zeiger, der auch eine Nulladresse sein darf.
@return Gibt den Wert des Arguments zurück, bei dem es sich 
auch um eine Nulladresse handeln kann. Die Rückgabe einer
Nulladresse bedeutet, daß diese Funktion mit einer Nulladresse
als Argumentwert aufgerufen wurde. */

int * f( int * const p ){ return p; }
int * g( int * const p ){ return 0; }
int main( void )
{ int i = 27; 
  puts( f( &i )? "1" : "0" ); 
  puts( f( 0  )? "1" : "0" ); 
  puts( g( &i )? "1" : "0" ); }

stdout

1
0
0

Der Autor einer Funktion sollte dokumentieren, ob eine Funktion eine Nulladresse zurückgeben kann, und was dies dann bedeutet.