Adressen und Zeiger Frage

[BastianW]

Hallo zusammen,

ich versuche mir gerade Zeiger und Adressen in C anzueignen. Ich habe ein paar Beispielaufgaben aber leider die Lösung nicht dazu. Kann mir jemand vielleicht mit der Lösung und etwas erklärung weiterhelfen?

int x =1, y=2, z[]={5,6,7} ;
int *ip, *iq;

ip=&x;           /* 1.) Was ist der inhalt von ip?  */
y=ip;              /* 2.) Was ist der inhalt von y? */
y=*ip;            /* 3.) Was ist der inhalt von y? */
*ip = 0;         /* 4.) Welche Variable ist nun Null? */
ip=&z[1];      /* 5.) Was ist der Inhalt von ip? */
*ip=*ip+10; /* 6.) Welche Variable wird erhöht? */
*ip += 3;      /* 7.) Welche Variable wird erhöht? */
++*ip;          /* 8.) Welche Variable wird erhöht? */
(*ip)++;       /* 9.) Welche Variable wird erhöht? */

iq = ip;
++ *iq; /* 10.) Welche Variable wird erhöht? */

 

[LSd]

Guten Abend,

bitte stell uns doch erstmal deine Lösungen vor.
Außerdem kannst du sie dir auch ausgeben lassen und dann darüber nachdenken warum das so ist.
Falls dann Fragen auftauchen helfen wir auch gern weiter.

Grüße

 

[BastianW]

Hey danke... Das ist doch mal eine Hilfe die ich gerne annehme...

Ich habe allerdings Probleme * und & sinvoll zu trennen (bzw. verstehe nicht so wirklich den Unterschied)...

* = Zeigervariable und greift auf den Inhalt des Zeigers zu
& = Addressoperator und greift auf die Adresse der Variablen zu

hier meine Überlegungen... aber wie gesagt ich stecke bei C noch in den Anfängen. Also nicht gleich mit der Keule schlagen ;-).

1.)
Der Zeigervariable ip wird die Speicherstelle (Adressoperator) von x zugeordnet.

2.)
Die Variable y hat die Speicherstelle (Adressoperator) von x.

3.)
Die Variable y hat den Wert der Speicherstelle (Adressoperator) x also 1.

4.)
Der Zeigervariablen wird die Speicherstelle (Adressoperator) 0 zugeordnet.

5.) [Vermute ich ist Falsch]
Der Zeigervariable wird die Speicherstelle von dem ersten Wert des Arrays (nicht 0) zugeordnet.

6.) [Da 5 falsch komme ich hier auch nicht weiter]
Der inhalt von ip wird um 10 erhöht.

7.)
Keine Idee

8.)
Keine Idee

9.)
Keine Idee


----
Nachtrag
Ich weiß das ich mit das mit printf anschauen kann. Nur verstehen tue ich es dadurch leider nicht.

 

[Marschal]

Alsooo

Das beispiel sollte dir gute Hilfe leisten, danach überprüf nochmal deine Lösungen

int a=5;// int a ist 5
   cout<<a<<endl;// Ausgabe: 5
   int *pa=&a;// int Zeiger pa ist Adresse von a
   *pa=6;// Inhalt von pa ist 6
   cout<<a<<endl;// Ausgabe: 6
   a=7;// a ist 7
   cout<<*pa<<endl;// Ausgabe: 7
   int b=8;// int b ist 8
   int *pb=pa;// int Zeiger pb ist pa, pb zeigt jetzt auch auf a
   cout<<*pb<<endl;// Ausgabe: 7
   int **ppa=&pa;// int Zeiger Zeiger ppa=Adresse von pa;
   cout<<**ppa<<endl;// Ausgabe: 7
   ppa=&pb;// Inhalt von ppa ist Adresse von pb;
   cout<<**ppa<<endl;// Ausgabe: 7
   pb=&b;// pb ist Adresse von b
   cout<<**ppa<<endl;// Ausgabe: 8

grundsätzlich ist zu sagen:
Alegen eines Zeigers:

int * p_int //zeiger auf einen datentyp(integer)

dereferenzieren des eigers, also Inhalt der Variable beispielsweise:

cout<< *p_int // somit wird angezeigt auf was der zeiger zeigt (Inhalt)

Adresse (speicherort):

cout<< &p_int //so erhälst du ne reihe von zahlen, wo deine variable speicher im Arbeitsspeicher bekommen hat

 

[Marschal]

(Sorry für Doppelpost, musste sein, wegen den Bedienelementen (CODE/QUOTE...))

Was auch ne möglichkeit ist, benutze ich persönlich lieber bei kleineren Sachen (also wens jezt nicht nen Zeiger auf eine Struktur, oder eine Liste ist..) sind sogenante Referenzen.

Vereinfacht gesagt: Referenzen sind Zeiger, die so tun, als wären sie die Variablen, auf die sie zeigen.

Bsp.:

int a=1;
   int &ra=a;// sprich: int Referenz ra ist a
   cout<<"a: "<<a<<endl;// Ausgabe: 1
   ra=2;
   cout<<"a: "<<a<<endl;// Ausgabe: 2

Warum ich die gerne benutze, wenn du aus einer Funktioin in die andere übergeben möchtest, dan kannst du glich im Prototyp die Referenz anlegen, und nicht Verschwenderisches duplizieren der Variablen

 

[maeTimmae]

Ich habe allerdings Probleme * und & sinvoll zu trennen (bzw. verstehe nicht so wirklich den Unterschied)...

* = Zeigervariable und greift auf den Inhalt des Zeigers zu
& = Addressoperator und greift auf die Adresse der Variablen zu

Das ist soweit richtig. Als Operatoren sind der Asterisk und Ampersand sozusagen gegensätzlich. Der Asterisk löst die Adresse auf und gibt den Inhalt zurück. Das Ampersand hingegen gibt die Adresse der Variable, auf die der Operator angewendet wird, zurück.

Die ersten drei Überlegungen sind, sofern ich mich nicht verguckt habe korrekt, bei Nummer vier ist dir aber ein kleiner Fehler unterlaufen.
Da ip aufgelöst wird, wird nicht der Zeiger, sondern der Speicherinhalt, auf den gezeigt wird, auf 0 gesetzt. (x = 0)
Was du beschreibst (Einfacherweise Null-Pointer genannt), erhielte man mit

ip = 0;

5. ist grundsätzlich richtig, bis auf die Tatsache, dass in C und C-Derivaten das Array-Element an Index 0 das erste Element, an Index 1 das zweite Element, usw sind. ip beinhaltet also die Adresse vom zweiten Element von z; ip zeigt also auf das zweite Element von z.

6.: Der Stern-Operator (Asterisk) löst den Pointer auf, und du kannst auf den Inhalt der Adresse, auf die gezeigt wird zugreifen. Somit wird nicht ip selbst, sondern der Inhalt der Adresse, auf welche ip zeigt gelesen und geändert.

7. Das selbe in Blau. Der "+="-Operator steht lediglich verkürzt für "*ip = *ip + 3".

8. Der (Pre-)Inkrement-Operator ist ein unärer Operator, welcher den Wert um eins erhöht (und den so berechneten Wert anschließend zurückgibt).

9. Der (Post-)Inkrement-Operator führt im Prinzip die selbe Operation wie der Pre-Inkrement-Operator durch, nur ist der Rückgabewert ein anderer: Der Wert vor dem durchführen der Operation wird zurückgegeben. Die Art der Implementierung macht Postfix-Operatoren (in C und C++) deshalb etwas ineffizienter, da vor jeder solchen Operation eine Kopie des Werts angelegt werden muss, welche anschließend zurückgegeben wird.

Für die Überprüfung hat dir Marschal netterweise ein Beispiel bereitgestellt, wie ich gerade sehe.
Die von ihm angesprochenen Referenzen haben im Wesentlichen aber nichts mit dem Ampersand als Operator zu tun, sondern sind wie der Asterisk bei der Initialisierung eines Pointers spezielle Schreibweisen.

 

[BastianW]

Vielen Dank schonmal... dann war ich ja gar nicht mal soooo dämlich . Wenigstens etwas verstanden .

zu 5.)
Ok, so wie du schriebst meine ich es auch. Allerdings etwas falsch ausgedrückt. Ich fange ja bei 0 an zu Zählen. Bei mir gibts einen 0 Wert und der Erste Wert... sinnvoller wäre es aber hier vom zweiten und nicht 1 Wert zu sprechen. Gebe ich dir recht, muss ich mir merken .

zu 6.)
ah ok danke... ich war mir hier unsicher weil *ip=*ip ... Halt ein Zeiger auf einen Zeiger.

zu 7.)
Da die Zeigervariable dann aufgelöst wird, wird der Inhalt um 3 erhöht richtig?

zu 8.)
++ davor bedeuted also die Zeigervariable wird aufgelöst und der Wert um 1 erhöht und ausgegeben.