Pointer-Wert *x &x und x

nehme an, dieser code:

main()
{
    int *x;
    *x = 3;

    printf("%d %d %d\n", *x, &x, x);
    //output 3 5448392 2293524
}

wenn *x ist der Wert; &x die addres; was bedeutet, dass der Wert von x?

Beachten Sie, dass Sie Zugriff auf random-Speicher mit Ihrem *x = 3 als x ist nicht initialisiert.

InformationsquelleAutor Fabricio | 2012-01-26

  1. 5
    Adr     value    expression
----------------------------------------------
5448392 2293524  &x address of x
2293524 3         x place where you assigned 3
    also, wenn wir deklarieren einen Zeiger deklarieren wir zwei Variablen 😀
    Nein, es ist eine Adresse, wo der Wert (3 in Frage) gespeichert ist, und der Zeiger selbst muss auch einen Platz im Speicher, die zum speichern der Adresse den Wert, auf die es hinweist.

    InformationsquelleAutor stacker

  2. 9
    • *x ist der Wert (korrekt)
    • x ist die Adresse des Wertes. BEARBEITEN In Ihrem Fall, diese Adresse nicht initialisiert ist, so ist es nicht auf überall in allem (Dank Keith Nikolaus für die Erwähnung).
    • &x ist die Adresse von [Zeiger, dass sollte enthalten] - Adresse der Wert.

    (es ist darauf hinzuweisen, dass Ihr Programm möglicherweise zum Absturz 🙂

    Letzte ist falsch, das ist die Adresse des Zeigers mit der Adresse des Wertes.
    das zweite ist auch falsch, es ist ein Zeiger kann eine Adresse enthalten, ein int) und in seinem Fall ist es nicht initialisiert ist

    InformationsquelleAutor dasblinkenlight

  3. 3

    x gibt Ihnen die Adresse im Speicher wo der Wert *x, d.h. 3 liegt. &x gibt die Adresse wo der Wert x, d.h. 2293524 liegt.

    x ist eine Adresse, ein Zeiger, der die Adresse enthält... der Unterschied ist, wo eine MENGE Leute bekommen mucked up von Zeigern und Adressen der locations.
    Danke. Ich verstehe den Unterschied, nur falsch ausgedrückt. Ist es jetzt besser? 🙂
    ja, ich dachte, sobald Sie wissen, Ihr einfach zu Verknüpfung der Art und Weise Sie Dinge sagen, ich weiß nur versucht zu erklären, es Menschen, die haben nie über Hinweise, die Sie bekommen all mucked up

    InformationsquelleAutor Sergey Kudriavtsev

  4. 2

    Es ist die Adresse, die x enthält. Nachdem erklärt wurde, wie ein Zeiger, x speichert eine Adresse, während &x ist in gewissem Sinne ein Zeiger auf einen Zeiger.

    EDIT: Also ich war nicht so präzise, wie ich vielleicht hätte sein sollen. &x ist streng genommen nicht um einen Zeiger auf einen Zeiger. Es ist die Adresse eines Zeigers. In der folgenden Zeile des Codes, y ist ein Zeiger auf einen Zeiger:

    int **y = &x;
    Meinst du "die Adresse enthält x" ?
    &x ist kein Zeiger auf einen Zeiger.... sehr wichtig, wie man aus bis diese ist einfach die Adresse des Zeigers, um einen Zeiger auf einen Zeiger, die Sie brauchen, um zu reservieren/deklarieren Sie einen Zeiger, den Sie dann setzen Sie die Adresse des Zeigers in.
    Nein. Ich meine so ziemlich das, was ich schrieb. x ist ein Zeiger, so wird dessen Wert eine Adresse. &x ist die Adresse des Speichers, der x-Wert.
    Fair genug. Antwort aktualisiert. 🙂
    Da muss ich widersprechen, auf Ihre Phrasierung. Die "Adresse x enthält" ist es ein Wert *x. Das ist, weil x ist ein Zeiger, und es "enthält" *x. "Adresse enthält x" (&x) ist seine Adresse.

    InformationsquelleAutor Stephen

  5. 2

    x ist ein Zeiger auf ein int, es ist nicht eine int-sich selbst, das ist nicht der Adresse eines int -, ein-Zeiger.

    einen Zeiger enthält eine Adresse einer int.

    so, ein Schritt fehlt, das Sie haben ( Ihr Programm nicht Punkt x zu nichts! sehr gefährlich)

    int y = 5;
int *x;

x = &y     //put the memory location of y into the pointer

    wenn Sie nun drucken Sie den Inhalt des Zeigers...

    printf("%d\n", x);    //prints out the memory location of y;

    bekommt jetzt den Wert von dem, was Ihr Zeiger zeigt ( im moment, y)

    printf("%p\n", *x);    //prints out 5;

    nun, wie y hat einen Speicherbereich, x hat auch einen Speicherort im Speicher

    also &x ist, wo der Zeiger 'x' ist im Speicher

    d umwandlungsspezifikator mit dem argument ein Zeiger-Typ ist Undefiniertes Verhalten.
    Insbesondere sollten Sie verwenden %p drucken pointer-Werte, und warf das argument (void *): printf("%p\n", (void *) x);.

    InformationsquelleAutor Keith Nicholas

  6. 1

    x nicht initialisiert ist, so weist es an nichts und die Dereferenzierung mit * ist Undefiniertes Verhalten.

    Wäre das folgende ein richtiger (und nützliches) Programm

    main()
{
    int x;   //declare an int variable
    int *xp; //declare a pointer to an int variable
    xp = &x;
    *xp = 3;

    printf("%d %d %d %d %d\n", x, &x, xp, *xp, &xp);
}

    x ist ein Wert, xp und &xp zeigen Sie auf, dass der Wert, *xp können verwendet werden, um Zugriff auf und ändern Sie den Wert und &xp ist ein Zeiger auf diesen Zeiger...

    d umwandlungsspezifikator mit dem argument ein Zeiger-Typ ist Undefiniertes Verhalten.
    Ich nahm an, es war nicht die beste, aber hielt es nicht ändern auch viel. Kennen Sie eine Plattform, wo dies ein Problem ist?

    InformationsquelleAutor hugomg

  7. 1

    &x ist die Adresse des Zeiger Objekt.
    Der Wert des Zeigers ist die Adresse einer int.

    Auch, Sie sollten nicht zuweisen *x, wie in Ihrem Beispiel: x nicht überall gültig.

    InformationsquelleAutor pmg

  8. 1

    x und &x Werte von Zeiger-Typen, so dass Sie verwenden sollten p umwandlungsspezifikator drucken Ihre Werte.

    printf("%d %p %p\n", *x, (void *) &x, (void *) x);

    Vergessen Sie nicht, zu werfen, um void * andernfalls wird der Aufruf an printfist Undefiniertes Verhalten. (p umwandlungsspezifikator erfordert ein argument des Typs void *).

    int *x;
int y = 0;      
x = &y; 
*x = 3;

    x ist ein Zeiger auf int. *x ist ein int und Ihr Wert ist 3. Und &x ist ein Zeiger auf einen Zeiger auf int. Beachten Sie, dass Ihre Zeiger muss auf eine gültige Objekt-Objekt (wie oben), ansonsten hat es einen ungültigen Wert.

    InformationsquelleAutor ouah

Schreibe einen Kommentar