Zeigeranalyse

[_BlueScreen]

Von der Schule bekamen wir folgende Aufgabe, nähmlich den unten stehenden Code zu analysieren und aufzuschreiben, was die Variablen für Werten besitzen bei den Punkten /*1*/, /*2*/ usw.
Ich fing schon einbisschen an mit der Aufgabe, doch komme nicht mehr weiter..
Ich wäre froh wenn mir jemanden helfen könnte dieser Aufgabe zulösen.

Der Code steht unten..
Danke im vorraus
_BlueScreen


typedef int* intptr;

int main(void)
{
intptr Ptr_a, Ptr_b, Ptr_c, Ptr_d, Ptr_e;
int Wert, Zahl;

/*1*/
Ptr_a = malloc(sizeof(int));
Ptr_b = malloc(sizeof(int));
Ptr_c = malloc(sizeof(int));
Wert = 10; Zahl = 3*Wert;
/*2*/
*Ptr_a = Wert; *Ptr_b = Zahl-Wert; *Ptr_c = 15;
Ptr_d = Ptr_a; Ptr_e = Ptr_c;
/*3*/
printf("*Ptr_a * Ptr_b *Ptr_c *Ptr_d *Ptr_e Wert Zahl\n");
printf("============================================\n");
printf(" %4i %4i %4i %4i %4i %4 %4\n", *Ptr_a, * Ptr_b, *Ptr_c, *Ptr_d,
*Ptr_e, Wert, Zahl);
Ptr_e = malloc(sizeof(int));
Zahl = (*Ptr_b + *Ptr_c)/2;
/*4*/
*Ptr_e = Zahl; Ptr_a = Ptr_e Wert= *Ptr_b + Zahl;
/*5*/
printf(" %4i %4i %4i %4i %4i %4 %4\n", *Ptr_a, * Ptr_b, *Ptr_c, *Ptr_d,
*Ptr_e, Wert, Zahl);
Ptr_b = Ptr_a; Ptr_d = Ptr_b; Wert=*Ptr_d; Zahl= *Ptr_e
*Ptr_c +=2;
/*6*/
printf(" %4i %4i %4i %4i %4i %4 %4\n", *Ptr_a, * Ptr_b, *Ptr_c, *Ptr_d,
*Ptr_e, Wert, Zahl);
}

 

[Beichtpfarrer]

Benutz am besten die coding-tags...
Sonst ist der Code ziemlich unübersichtlich und es sieht niemand wirklich mehr als du..


Außerdem solltest du sagen, wo bei dir das Verständnis hängt...
Also ab wo es sich lohnt, was zu erklären..

Nicht dass man dir jetzt ewig Sachen sagt, die du sowieso schon weißt...

 

[_BlueScreen]

also ja z.b ich verstehe nicht was mit "Ptr_a = malloc(sizeof(int));" an Ptr_a zugewiesen wird bzw. was es jetzt für einen Wert erhält. Oder auch den unterschied zwischen *Ptr_a und Ptr_a.
Und stimmt es das "Zahl = (*Ptr_b + *Ptr_c)/2;" eigentlich nicht erlaubt ist, denn ich dachte man dürfte nur die Subtraktion zweier Zeiger machen.

Das wäre das meiste was ich nicht verstehe.
MFG

 

[_Van]

also ja z.b ich verstehe nicht was mit "Ptr_a = malloc(sizeof(int));" an Ptr_a zugewiesen wird bzw. was es jetzt für einen Wert erhält.

Lass mich mal dir bissel Bildhaft und stark vereinfacht das erklären.

http://img217.imageshack.us/img217/2563/malloc1zt3.jpg
http://img185.imageshack.us/img185/6934/malloc2lo6.jpg
http://img261.imageshack.us/img261/3748/malloc3ol2.jpg
http://img185.imageshack.us/img185/5014/malloc4vy9.jpg

d.h. ein Pointer ist wirklich nichts anderes als nur ein Zeiger.
Der zeigt auf eine bestimmte Speicherstelle. Mehr nicht.

Du beauftragst malloc() nur nach einer bestimmten freien Speichergröße
(ob zusammenhängend oder nicht spielt keine rolle für dich)
zu suchen und die dann für dein Programm zu regestrieren.

So, somit gehört der Speicherplatz dort dann dir und damit du
ihn auch mit irgendetwas belegen kannst kriegst du einen Zeiger
als return zurück. Der zeigt auf den ersten Bit von deinem reserviertem
Speicher.

D.h. es wird kein Wert definiert! Aber es kann immernoch irgendein
Krimskrams drine stehen. Mehr Infos hier: http://www.cplusplus.com/reference/clibrary/cstdlib/malloc.html

Oder auch den unterschied zwischen *Ptr_a und Ptr_a.

Wegen deinem "typedef int* intptr;" fast am Anfang des Codes sind deine
Ptr_X Pointer alles Pointer. Den intptr ist ein Substitut für int* <- Pointer definierung.

D.h. "typedef int* intptr; intptr Ptr_a;" == "int * Ptr_a;"

Dieser Stern sagt dem Compiler das diese Variable die gerade initialisiert wird
eigentlich ein Pointer ist.

Aber, dieser Stern sagt auch bei einem schon initialisiertem Pointer das
der Speicherplatz auf den der Pointer zeigt ausgelesen/beschrieben werden soll.

Ptr_a == Adresse
*Ptr_a == Wert

Mehr Infos: http://www.galileo-press.de/openbook/c_von_a_bis_z/c_014_000.htm#Xxx999328

Und stimmt es das "Zahl = (*Ptr_b + *Ptr_c)/2;" eigentlich nicht erlaubt ist, denn ich dachte man dürfte nur die Subtraktion zweier Zeiger machen.

Wie oben schon erzählt bedeutet das * vorm Pointer das der Wert gelesen werden soll.
D.h. "Zahl = (*Ptr_b + *Ptr_c)/2;" == "Zahl = (Wert_auf_dem_der_Pointer_b_zeigt + Wert_auf_dem_der_Pointer_c_zeigt) / 2;"
Hier werden nicht mit den Pointern gerechnet sondern mit den Werten auf die
die Pointer zeigen.



Ich hoffe ich konnte dir das ganze bissel näher bringen, bin selber ein
Anfänger in diesem Gebiet. Falls ich was falsch erzählt habe bitte nicht hauen D:

edit:

du solltest mal deine "Schreibschrift" ein bissel aufbessern. Hier ein Beispiel wie ich das machen würde:

#include <stdio.h>

typedef int* intptr;

int main(void) {

	intptr Ptr_a, Ptr_b, Ptr_c, Ptr_d, Ptr_e;
	// int *Ptr_a, *Ptr_b, *Ptr_c, *Ptr_d, *Ptr_e;
	// ist das gleiche!
	
	int Wert, Zahl; // ganz normale Variablen

	/*---------1--------*/
	Ptr_a = malloc(sizeof(int)); // fehlt da nicht ein (int*) caster
	Ptr_b = malloc(sizeof(int)); // vorm malloc?
	Ptr_c = malloc(sizeof(int)); // oder ist es nicht mehr nötig?
	
	Wert = 10;
	Zahl = 3 * Wert; 
	// Wert == 10
	// Zahl == 30
	
	/*---------2--------*/
	*Ptr_a = Wert; 
	*Ptr_b = Zahl - Wert; 
	*Ptr_c = 15; 
	// *Ptr_a == 10
	// *Ptr_b == 20
	// *Ptr_c == 15
	
	Ptr_d = Ptr_a; // gezeigte Adresse von Ptr_d == gezeigte Adresse von Ptr_a
	Ptr_e = Ptr_c; // gezeigte Adresse von Ptr_e == gezeigte Adresse von Ptr_c
	
	/*---------3---------*/
	printf("*Ptr_a * Ptr_b *Ptr_c *Ptr_d *Ptr_e Wert Zahl\n");
	printf("============================================\n");
	printf(" %4i %4i %4i %4i %4i %4 %4\n", *Ptr_a, *Ptr_b, *Ptr_c, *Ptr_d, *Ptr_e, Wert, Zahl); // kein plan warum %4...
	// Da oben werden alle Werte gezeigt auf die die Pointer zeigen und die Werte von den Variablen
	
	Ptr_e = malloc(sizeof(int)); // Ptr_e kriegt neuen Speicher zugewiesen
	
	Zahl = (*Ptr_b + *Ptr_c)/2; // (Wert_auf_dem_der_Pointer_b_zeigt + Wert_auf_dem_der_Pointer_c_zeigt) / 2
	
	/*---------4---------*/
	*Ptr_e = Zahl; 
	Ptr_a = Ptr_e;
	Wert= *Ptr_b + Zahl;
	// Dürfte nun langsam klar sein
	
	/*---------5---------*/
	printf(" %4i %4i %4i %4i %4i %4 %4\n", *Ptr_a, *Ptr_b, *Ptr_c, *Ptr_d, *Ptr_e, Wert, Zahl);
	
	Ptr_b = Ptr_a; 
	Ptr_d = Ptr_b; 
	Wert = *Ptr_d; 
	Zahl = *Ptr_e
	*Ptr_c += 2;
	// Dürfte auch klar sein
	
	/*---------6--------*/
	printf(" %4i %4i %4i %4i %4i %4 %4\n", *Ptr_a, *Ptr_b, *Ptr_c, *Ptr_d, *Ptr_e, Wert, Zahl);
	
	return 0; // fehlte!
}