Frage zu structs und Pointern

Novio

Hallo.

//---------------------------------------------------------------------------

#include <stdio.h>
struct str{
	int zahl;
	struct str *next;
};

struct str *anfang = NULL;
struct str *aktuell = NULL;

void neu(int x){
	struct str *zeiger;
	zeiger = malloc(sizeof(struct str));
	zeiger->zahl = x;
	zeiger->next = NULL;

	if(anfang == NULL){
		anfang = zeiger;
		aktuell = zeiger;

	}
	else{
		aktuell->next = zeiger;
		aktuell = aktuell->next;
	}
}

void ausgabe2(){

	printf("Gr     :  %d",sizeof(struct str)); // 8, 4 wegen int und 4 wegen dem Pointer
	printf("\nZahl +0 :  %d", (anfang+0)->zahl); //0 
	printf("\nZahl +1 :  %d", (anfang+1)->zahl); //0
	printf("\nZahl +2 :  %d", (anfang+2)->zahl); //1
	printf("\nZahl +3 :  %d", (anfang+3)->zahl); //0
	printf("\nZahl +4 :  %d", (anfang+4)->zahl); //2
	printf("\nZahl +6 :  %d", (anfang+6)->zahl); //3
	printf("\nZahl +8 :  %d", (anfang+8)->zahl); //4
	printf("\nZahl +12:  %d", (anfang+12)->zahl);//6
	printf("\nZahl +16:  %d", (anfang+16)->zahl);//8
	printf("\n");

}

int main(int argc, char* argv[])
{   int e;

   for(e = 0; e < 10; e++){
    	neu(e);
   }

	ausgabe2();
	system("pause");
	return 0;
}

Ich habe eine Frage speziell zu der Funktion "ausgabe2()".
In dem Programm erstelle ich eine dynamische Datenliste. Jedes struct hat den Integer "zahl" ( und den Pointer natürlich).
Es werden 10 Structs mit den Zahlen von 0 - 9 erstellt. Das klappt alles wunderbar.

Wenn ich jedoch in "ausgabe2()" versuche vom Pointer "anfang" aus diese Zahlen auszugeben, kommt eine Ausgabe zustande, die ich nicht verstehe ( Die Ausgaben sind der Kommentar hinter der jeweiligen printf-Zeile).

Wieso greif ich vom Pointer "anfang" mit
printf("\nZahl +2 : %d", (anfang+2)->zahl); auf die 1. struct,
printf("\nZahl +4 : %d", (anfang+4)->zahl); auf die 2. struct,
printf("\nZahl +6 : %d", (anfang+6)->zahl); auf die 3. struct,

usw. zu? Müsste die nächste struct nicht (anfang+1)->zahl sein?

Hier in diesem Fall ist es doch auch so:

int ptr*;
   ptr = calloc(4,sizeof(int));
   ptr[0] = 1;
   ptr[1] = 2;
   ptr[2] = 3;
   ptr[3] = 4;

Mit printf("%d",*(ptr+1)); würde ich zB. die 2 kriegen, weil in diesem Fall +1 4 Byte sind, da der Pointer auf einen Integer zeigt.

Deshalb habe ich angenommen, dass bei

printf("\nZahl +1 :  %d", (anfang+1)->zahl);

das +1 8 Byte wären da der Pointer auf ein struct str zeigt.

Aber wieso greife ich mit +2,+4,+6,+8,... auf die nächste Struktur zu? Das wären doch jedesmal 8 Byte. Denke mal das ist der Grund oder?

Oder ist das so dass *(ptr+1) immer 4 Bytes weiter sind, unabhängig vom Typ des Pointers? Und wieso gerade 4 Bytes? Weil ein Pointer 4 Byte groß ist?

Wenn ja, ist das bei einem void Pointer auch so? Der ist ja nur 1 Byte so viel ich weiss.

Danke

Wutz

Eine Linklist ist kein Array, deshalb kannst du auf eine Linklist auch nicht wie auf ein Array zugreifen. Es sind 2 grundsätzlich verschiedene Datenstrukturen, die Lektüre in einem guten Lehrbuch wäre für dich besser als solch ein Stochern im Nebel.

Novio

Eine Leküre hab ich schon gelesen, aber genau dieses Problem wurde da nicht geschildert

So mein lieber...
Wie schon gesagt wurde Liste!=Array.
Wenn du anfang+1 macht heisst das: dass du den Zeiger um 1 (kein plan wie gross es bei einer stuctur ist,xD 8 oder 4..?) erhöht. Da Array immer im Ram hintereinander folgen ist es mögich via Zeigerartitmetik auf das nächste zuzugreifen. Bei listen jedoch kann sie die Liste einmal am Meer und im Himalaya im Ram befinden, und da kommst du mit Zeigeraritmetik nicht sehr weit (Bergsteiger braucht auch mehr als 1 Schritt).
In einer liste wechselt man mit pointer die auf structuren zeigen den standort, wie in Starwars. pNext->pNext->pUnten->pNotausgang->pTot.pZahl.
Den Rest kannst du dir selber zusammenreimen...

Novio

Ahhhh, okay verstanden, danke

Binggi

Ich hab mal eine Variante gesehen, da hat einer den Pointer auf die Stuctur also in deinen Fall den Zeiger ausgegeben, dadurch kommt man auf die Zahl, also

printf("%d",*aktuell);

Daraus folgt, dass array + sizeof int der zeiger auf next ist.

*anfang //1

*anfang->next //2

*anfang->next->next //3

*anfang->next->next->next //4

So kamm man das auch machen wenn man möchte... aber ist nicht zu empfehlen!!

Binggi schrieb:

Ich hab mal eine Variante gesehen, da hat einer den Pointer auf die Stuctur also in deinen Fall den Zeiger ausgegeben, dadurch kommt man auf die Zahl, also
printf("%d",*aktuell);
Daraus folgt, dass array + sizeof int der zeiger auf next ist.
*anfang //1
*anfang->next //2
*anfang->next->next //3
*anfang->next->next->next //4
So kamm man das auch machen wenn man möchte... aber ist nicht zu empfehlen!!

Das funktioniert aber nur, falls wirklich das struct so definiert wurde, wie in diesem Beispiel. Wenn z.B. zuerst der Pointer auf das nächste Element und dann int zahl; kommen würde, gibst du die ersten Bytes (evtl alle) des Pointers von next als int aus.