Ich hatte Dinge wie geschrieben

char *x=NULL;

unter der Annahme, dass

 char *x=2;

würde einen charZeiger auf Adresse 2 erstellen .

Im Programmier-Tutorial für GNU C heißt es jedoch, dass int *my_int_ptr = 2;der ganzzahlige Wert 2bei der my_int_ptrZuweisung an eine beliebige zufällige Adresse gespeichert wird.

Dies scheint zu implizieren, dass mein eigener char *x=NULLWert NULLeiner charbeliebigen Adresse im Speicher zuweist, was auch immer der Wert von cast für a ist.

Während

#include <stdlib.h>
#include <stdio.h>

int main()
{
    char *x=NULL;

    if (x==NULL)
        printf("is NULL\n");

    return EXIT_SUCCESS;
}

druckt in der Tat

ist Null

Wenn ich es kompiliere und ausführe, mache ich mir Sorgen, dass ich mich auf undefiniertes oder zumindest unterbestimmtes Verhalten verlasse und schreiben sollte

char *x;
x=NULL;

stattdessen.

Ist es möglich, einen C-Zeiger auf NULL zu initialisieren?

TL; DR Ja, sehr.

Die tatsächliche Behauptung auf dem Leitfaden lautet wie folgt

Wenn Sie jedoch nur die einzelne Anfangszuweisung verwenden, int *my_int_ptr = 2;versucht das Programm, den Inhalt des Speicherorts, auf den durch gezeigt wird, my_int_ptrmit dem Wert 2 zu füllen . Da er my_int_ptrmit Müll gefüllt ist, kann es sich um eine beliebige Adresse handeln. [...]

Nun, sie sind falsch, du hast recht.

Für die Aussage ( ignoriert vorerst die Tatsache, dass der Zeiger auf die Ganzzahlkonvertierung ein implementierungsdefiniertes Verhalten ist )

int * my_int_ptr = 2;

my_int_ptr ist eine Variable (vom Typ Zeiger auf int ), sie hat eine eigene Adresse (Typ: Adresse des Zeigers auf Ganzzahl), Sie speichern einen Wert von 2in dieser Adresse.

Da my_int_ptres sich nun um einen Zeigertyp handelt, können wir sagen, dass er auf den Wert von "Typ" an der Speicherstelle zeigt, auf die gezeigt wird die der Wert zeigt, inmy_int_ptr . Also, Sie sind im Wesentlichen den Wert Zuordnung von der Zeigervariable, nicht der Wert des Speicherplatzes , auf den durch den Zeiger.

Also zum Abschluss

 char *x=NULL;

initialisiert die Zeigervariable xaufNULL , nicht auf den Wert an der Speicheradresse, auf die der Zeiger zeigt .

Dies ist das gleiche wie

 char *x;
 x = NULL;    

Erweiterung:

Nun, streng konform, eine Aussage wie

 int * my_int_ptr = 2;

ist illegal, da es sich um eine Verletzung von Einschränkungen handelt. Deutlich sein,

• my_int_ptr ist eine Zeigervariable vom Typ int *
• Eine Ganzzahlkonstante 2hat intper Definition einen Typ .

und da es sich nicht um "kompatible" Typen handelt, ist diese Initialisierung ungültig, da sie gegen die Regeln der einfachen Zuweisung verstößt, die in Kapitel 6.5.16.1 / P1, beschrieben in Lundins Antwort, erwähnt werden .

Falls jemand interessiert ist, wie die Initialisierung mit einfachen Zuweisungsbeschränkungen verbunden ist, zitieren Sie C11, Kapitel §6.7.9, P11

Der Initialisierer für einen Skalar muss ein einzelner Ausdruck sein, der optional in geschweiften Klammern eingeschlossen ist. Der Anfangswert des Objekts ist der des Ausdrucks (nach der Konvertierung). Es gelten die gleichen Typbeschränkungen und Konvertierungen wie für die einfache Zuweisung, wobei der Typ des Skalars als nicht qualifizierte Version seines deklarierten Typs angesehen wird.

Das Tutorial ist falsch. In ISO C int *my_int_ptr = 2;ist ein Fehler. In GNU C bedeutet dies dasselbe wie int *my_int_ptr = (int *)2;. Dies konvertiert die Ganzzahl 2in eine Speicheradresse, wie vom Compiler festgelegt.

Es wird nicht versucht, etwas an dem von dieser Adresse adressierten Ort (falls vorhanden) zu speichern. Wenn Sie weiter schreiben würden *my_int_ptr = 5;, würde es versuchen, die Nummer 5an dem von dieser Adresse adressierten Ort zu speichern .

Um zu verdeutlichen, warum das Tutorial falsch ist, int *my_int_ptr = 2; handelt es sich um eine "Einschränkungsverletzung". Es handelt sich um Code, der nicht kompiliert werden darf, und der Compiler muss Ihnen bei Auftreten eine Diagnose stellen.

Gemäß 6.5.16.1 Einfache Zuordnung:

Einschränkungen

Eine der folgenden Bedingungen gilt:

• Der linke Operand hat einen atomaren, qualifizierten oder nicht qualifizierten arithmetischen Typ, und der rechte hat einen arithmetischen Typ.
• Der linke Operand hat eine atomare, qualifizierte oder nicht qualifizierte Version einer Struktur oder eines Vereinigungstyps, der mit dem Typ des rechten kompatibel ist.
• Der linke Operand hat einen atomaren, qualifizierten oder nicht qualifizierten Zeigertyp, und (unter Berücksichtigung des Typs, den der linke Operand nach der Wertkonvertierung haben würde) sind beide Operanden Zeiger auf qualifizierte oder nicht qualifizierte Versionen kompatibler Typen, und der Typ, auf den der linke zeigt, hat alle die Qualifikanten des Typs, auf den rechts hingewiesen wird;
• Der linke Operand hat einen atomaren, qualifizierten oder nicht qualifizierten Zeigertyp, und (unter Berücksichtigung des Typs, den der linke Operand nach der Wertkonvertierung haben würde) ist ein Operand ein Zeiger auf einen Objekttyp und der andere ein Zeiger auf eine qualifizierte oder nicht qualifizierte Version von nichtig, und der Typ, auf den links gezeigt wird, enthält alle Qualifikationsmerkmale des Typs, auf den rechts gezeigt wird;
• Der linke Operand ist ein atomarer, qualifizierter oder nicht qualifizierter Zeiger, und der rechte ist eine Nullzeigerkonstante. oder
• Der linke Operand hat den Typ atomar, qualifiziert oder nicht qualifiziert _Bool, und der rechte ist ein Zeiger.

In diesem Fall ist der linke Operand ein nicht qualifizierter Zeiger. Nirgends wird erwähnt, dass der richtige Operand eine ganze Zahl (arithmetischer Typ) sein darf. Der Code verstößt also gegen den C-Standard.

Es ist bekannt, dass sich GCC schlecht verhält, es sei denn, Sie weisen ausdrücklich an, dass es sich um einen Standard-C-Compiler handelt. Wenn Sie den Code als kompilieren -std=c11 -pedantic-errors, wird eine Diagnose korrekt angezeigt, wie dies erforderlich ist.

int *my_int_ptr = 2

speichert den ganzzahligen Wert 2 an einer beliebigen zufälligen Adresse in my_int_ptr, wenn diese zugewiesen wird.

Das ist völlig falsch. Wenn dies tatsächlich geschrieben ist, besorgen Sie sich bitte ein besseres Buch oder Tutorial.

int *my_int_ptr = 2Definiert einen ganzzahligen Zeiger, der auf Adresse 2 zeigt. Wenn Sie versuchen, auf die Adresse zuzugreifen, kommt es höchstwahrscheinlich zu einem Absturz 2.

*my_int_ptr = 2, dh ohne das intin der Zeile, speichert den Wert zwei an einer beliebigen zufälligen Adresse my_int_ptr, auf die gezeigt wird. Nachdem Sie dies gesagt haben, können Sie NULLeinem Zeiger zuweisen , wenn er definiert ist. char *x=NULL;ist vollkommen gültig C.

Bearbeiten: Während ich dies schrieb, wusste ich nicht, dass die Konvertierung von Ganzzahlen in Zeiger ein implementierungsdefiniertes Verhalten ist. Weitere Informationen finden Sie in den guten Antworten von @MM und @SouravGhosh.

Eine Menge Verwirrung über C-Zeiger kommt von einer sehr schlechten Wahl, die ursprünglich in Bezug auf den Codierungsstil getroffen wurde, was durch eine sehr schlechte kleine Wahl in der Syntax der Sprache bestätigt wird.

int *x = NULL;ist richtig C, aber es ist sehr irreführend, ich würde sogar unsinnig sagen, und es hat das Verständnis der Sprache für viele Anfänger behindert. Man denkt, wir könnten später etwas tun, *x = NULL;was natürlich unmöglich ist. Sie sehen, der Typ der Variablen ist nicht intund der Name der Variablen ist nicht *x, noch spielt die *in der Deklaration eine funktionale Rolle in Zusammenarbeit mit der =. Es ist rein deklarativ. Was also viel sinnvoller ist, ist Folgendes:

int* x = NULL;Das ist auch richtig C, obwohl es nicht dem ursprünglichen K & R-Codierungsstil entspricht. Es macht vollkommen klar, dass der Typ int*und die Zeigervariable ist x, so dass selbst für den Uneingeweihten, in dem der Wert NULLgespeichert wird x, der ein Zeiger ist, deutlich wirdint .

Darüber hinaus ist es einfacher, eine Regel abzuleiten: Wenn der Stern vom Variablennamen entfernt ist, handelt es sich um eine Deklaration, während der an den Namen angehängte Stern eine Zeiger-Dereferenzierung darstellt.

Jetzt wird es viel verständlicher, dass wir es weiter unten entweder tun können, x = NULL;oder *x = 2;mit anderen Worten, es macht es für einen Anfänger einfacher zu sehen, wie es variable = expressionzu pointer-type variable = pointer-expressionund führtdereferenced-pointer-variable = expression . (Für den Eingeweihten meine ich mit 'Ausdruck' 'Wert'.)

Die unglückliche Wahl in der Syntax der Sprache ist, dass Sie beim Deklarieren lokaler Variablen sagen können, int i, *p;welche eine Ganzzahl und einen Zeiger auf eine Ganzzahl deklarieren, sodass man glaubt, dass dies *ein nützlicher Teil des Namens ist. Dies ist jedoch nicht der Fall, und diese Syntax ist nur ein eigenartiger Sonderfall, der der Einfachheit halber hinzugefügt wurde. Meiner Meinung nach hätte sie niemals existieren dürfen, da sie die oben vorgeschlagene Regel ungültig macht. Soweit ich weiß, ist diese Syntax nirgendwo anders in der Sprache von Bedeutung, aber selbst wenn dies der Fall ist, weist sie auf eine Diskrepanz bei der Definition von Zeigertypen in C hin. Überall sonst, in Deklarationen mit einzelnen Variablen, in Parameterlisten, In Strukturelementen usw. können Sie Ihre Zeiger als type* pointer-variableanstelle von deklarieren type *pointer-variable. es ist vollkommen legal und macht mehr Sinn.

Ich möchte den vielen ausgezeichneten Antworten etwas Orthogonales hinzufügen. Tatsächlich ist das Initialisieren auf NULLkeine schlechte Praxis und kann nützlich sein, wenn dieser Zeiger zum Speichern eines dynamisch zugewiesenen Speicherblocks verwendet werden kann oder nicht.

int * p = NULL;
...
if (...) {
    p = (int*) malloc(...);
    ...
}
...
free(p);

Da gemäß der Norm ISO-IEC 9899 free ein Nein ist, wenn das Argument lautet NULL, ist der obige Code (oder etwas Bedeutenderes in der gleichen Richtung) legitim.

Dies ist ein Nullzeiger

int * nullPtr = (void*) 0;

Das ist richtig.

int main()
{
    char * x = NULL;

    if (x==NULL)
        printf("is NULL\n");

    return EXIT_SUCCESS;
}

Diese Funktion ist korrekt für das, was sie tut. Es weist dem Zeichenzeiger x die Adresse 0 zu. Das heißt, es zeigt den Zeiger x auf die Speicheradresse 0.

Alternative:

int main()
{
    char* x = 0;

    if ( !x )
        printf(" x points to NULL\n");

    return EXIT_SUCCESS;
}

Meine Vermutung, was Sie wollten, ist:

int main()
{
    char* x = NULL;
    x = alloc( sizeof( char ));
    *x = '2';

    if ( *x == '2' )
        printf(" x points to an address/location that contains a '2' \n");

    return EXIT_SUCCESS;
}

x is the street address of a house. *x examines the contents of that house.