[C] Probleme mit Zeigern

[Star4000]

Hallo liebe Community
Ich sitze an einer Aufgabe wo ich absolut nicht weiterkomme und würde mich mal über aufweckende Worte freuen die mir erläutern wie die Ausgabe zustande kommt.
Erstmals der Code

#include <stdio.h>

void main (void)

{
	int a[3], *d[3], **x;

		*a=5 ; // Zeigervariable Feldname ohne eckigen Klammern Element des ersten Feldelements
		a[1]=7;

		a[2]=10;
		*(d+1)= a+1;
		x=d+1;
	printf ("Adresse von a[0] : %lx \n Inhalt von a[0]: %d  \n \n", (unsigned long)&a[0], a[0]);

	printf ("Adresse von a[1] : %lx \n Inhalt von a[1]: %d  \n \n", (unsigned long)&a[1], a[1]);

	printf ("Adresse von a[2] : %lx \n Inhalt von a[2]: %d  \n \n", (unsigned long)&a[2], a[2]);


	printf ("Adresse von d[0] : %lx \n Inhalt von d[0]: %lx  \n \n", (unsigned long)&d[0],(unsigned long) d[0]);

	printf ("Adresse von d[1] : %lx \n Inhalt von d[1]: %lx  \n \n", (unsigned long)&d[1],(unsigned long) d[1]);

	printf ("Adresse von d[2] : %lx \n Inhalt von d[2]: %lx  \n \n", (unsigned long)&d[2],(unsigned long) d[2]);

	printf (" Adresse von x: %lx \n Inhalt von x: %lx  \n \n" , (unsigned long) &x, (unsigned long)x);
}

Ich bekomme also heraus eine Liste mit Adressen und den jeweiligen Inhalten der Variablen a[0] a[1] ----- bis x. wie kommt der rechner auf den Inhalt bei den Variablen d [0] - x?! ich weiss oben ist es jeweils deklariert

*(d+1)= a+1;
x=d+1;

aber genau diese Deklarartion versteh ich nicht.

Vielen Dank für Hilfe.

MfG: Star

 

[dubberle]

Das Feld a ist klar: Du hast drei integer Werte nach einander.
Im Feld d hast du drei Zeiger, die jeweils auf einen integer Wert zeigen.

Wollen wir also "*(d+1)= a+1" aufdröseln:
Der zweite Zeiger im Feld d ("d+1") zeigt auf einen integer Wert. Der Zeiger wird dereferenziert also wird nicht der Zeiger, sondern der Wert, auf den er zeigt, verändert.

a ist ein Zeiger auf einen integer Wert (konkret das erste Element des Feldes a), a+1 ist ein Zeiger auf den zweiten integer Wert, also eine Adresse.

Es mag nun ungewöhnlich sein, einem integer Wert (also *(d+1)) eine Adresse zuzuweisen, aber Adressen sind ja auch nur Zahlen. Im Grunde wird implizit gecastet:

*(d+1) = a+1 ist gleichwertig zu *(d+1) = (unsigned long) (a+1)

Im Endeffekt steht nun in d[1] eine Zahl, die als Adresse eines Integers aufgefasst werden kann.

wenn denn eine Adresse auf der jeweiligen Architektur gerade einen usigned long groß ist.

x ist ein Zeiger, der auf einen Zeiger verweist, der auf einen integer Wert zeigt.

mit x = d+1 wird in x die Adresse aus d[1] abgelegt. x zeigt anschließend auf a[1]

 

[SvenF311]

Wo ist das Problem? Also mal abgesehen davon, dass der Code keinen erkennbaren Zweck erfüllt und überhaupt eigentlich nur Verwirrung stiftet.

Okay, a ist ein Array aus 3 int, d ist ein Array aus 3 Pointern auf int und x ist eine Pointer auf einen Pointer auf int (etwa das gleiche, wie d).

In Zeile 12 wird dem zweiten Pointer aus b die Adresse des zweiten int aus a zugewiesen. Und dann wird x die Adresse des zweiten Pointers aus b zugewiesen. - Keine Ahnung, welchen Sinn das hat.

Aber vielleicht wird der Code verständlicher, wenn du dir die Operatoren * (Dereferenzierung) und & (Referenzierung bzw. Adresse von) mal anguckst. Du kannst nämlich *(d+1) auch als d[1] schreiben und x+1 entspricht &x[1].

Die Zeilen 12 und 13 könnte man also auch als
d[1] = &a[1];
x = &d[1];
scheiben.

Bei der Ausgabe enthalten die Pointer d[0] und d[2] übrigens keine gültigen Adressen.

<edit>

mit x = d+1 wird in x die Adresse aus d[1] abgelegt. x zeigt anschließend auf a[1]

x bekommt die Adresse von d[1] zugewiesen und x zeigt danach auf die Adresse von a[1], es gilt **x == x[0][0] == a[1].
</edit>