Zeiger: wofür braucht man die?

[-[RiDER]-]

Hi

In dem ersten Buch über C, das ich gelesen habe stand, was ich gut einleuchtend fand. Es ist vielleicht nicht sooooo fachmännisch, aber mir hats geholfen. Ich kanns grad nicht zitieren (GreetZ @ BlackBerry ), aber sinngemäß lautete es etwa wie folgt (wir gehen davon aus, dass i als Zeiger auf irgendeine Variable von irgendeinem Typen (von mir aus T) deklariert ist, sagen wir foo):

&i gibt die Adresse des Zeigers an (den Ort, wo sich der Zeiger im Speicher befindet).
i gibt die Adresse an, auf die der Zeiger i zeigt (den Ort, wo foo im Speicher steht).
*i gibt den Wert der Variable an, auf die i zeigt, also den Wert von foo.

Als Bild vielleicht so, wobei alles außer "Wert von foo" (was der Wert der Variable sein soll, auf die i zeigt) Adressen sind:

+----+
|    |
| &i |--+
|    |  |   +---+
+----+  |   |   |
        +-->| i |--+
            |   |  |   +----+
            +---+  |   |    |
                   +-->| *i |----+
                       |    |    |
   +--------------+    +----+    |
   |              |              |
   | Wert von foo |<-------------+
   |              |
   +--------------+

Wenn man sich das so vorstellt, kann man sich auch denken, wie man den Kram verschachteln kann, z.B. als &((*)(&*i)), zumindest isses bei mir so

Vielleicht hilfts...
GreetZ RiDER

EDiT: Vielleicht noch zu erwähnen, dass i == &foo und &*i == &foo, also i == &*i ist.
Und *&i == &*i, wobei das erste bedeutet: "Wert dessen, was in 'Adresse von i' (also &i) steht", und das zweite: "Adresse des 'Ortes, an dem der Wert der Variable, auf die i zeigt (also foo)' (also *i) steht" und beides entspricht i.
Man kann also beliebig auf irgendwelchen Ebenen herumhopsen, die sogar noch nichtmal existieren müssen, so z.B. &&&&&*****i == i, fast schon wie mit Brüchen rechnen... und ich laber schon wieder so fett...

[Darkthief]

yap, das Buch aus dem du zitiert hast hab ich auch.
Von daher hats nicht wirklich geholfen.
das der unäre Operator den inhalt der Variable auf die gezeigt wird ausgibt und der & Operator die Adresse des Zeigers ausgibt hab ich verstanden.
Was ich jetzt nur wissen wollte:
ist
(*zi) += 5;
dasselbe wie
i += 5;
?

außerdem:
(*i)++;
dürfte doch garnichts verändern, da ja das postfix increment verwendet
wird.

edit:
ich habs grat getestet und versteh jetzt echt nicht, warum (*i)++ was verändert und i++ nicht -.-

[blackberry]

Was ich jetzt nur wissen wollte:
ist
(*zi) += 5;
dasselbe wie
i += 5;
?

Wenn ich davon ausgehen darf, dass "zi" ein Zeiger auf "i" ist, dann sind beide oben beschriebenen Ausdrücke äquivalent.

ich habs grat getestet und versteh jetzt echt nicht, warum (*i)++ was verändert und i++ nicht -.-

Ich hab's selbstverständlich auch getestet bevor ich es gepostet habe (kompilieren kostet mich sowieso nur einen Befehl im Terminal).

außerdem:
(*i)++;
dürfte doch garnichts verändern, da ja das postfix increment verwendet
wird.

Wir fassen zusammen:
zi++;
erhöht den Zeiger um eins.
ASCII-Grafik (RiDER ist mein Idol )

---+                zi (vom Typ int *) zeigt auf...
   |
 _ # _ _ _ _ _      Speicher

zi++;

-----+              zi (vom Typ int *) zeigt auf...
     |
 _ _ # _ _ _ _ _    Speicher

*zi;
Gibt eine Integer-Variable zurück, welche den Speicherbereich mit "i" Teilt.
Eine Veränderung dieses Speicherbereies (zB. durch inkrementation) hat eine Änderung aller Variablen zu folge, die diesen Speicherbereich teilen.

Kurz gesagt:
*zi und i sind äquivalent, weil sie sich den selben Speicherbereich teilen.


PS: sorry für die späte Antwort - der Topic ist irgendwie unter den anderen untergegangen


mfG. BlackBerry

[Darkthief]

ok, aber bei deinen beiden codeschnipseln oben hat i++ i nicht bleibend verändert (*i)++ aber schon.

zu deiner ascii grafik:
würde das bedeuten, das zi++ (ja, zi ist bei mir ein zeiger) den zeiger auf einen anderen punkt im speicher zeigen lässt, er also nichtmehr auf i zeigt? (angenommen er hat vorher auf i gezeigt)

[blackberry]

ok, aber bei deinen beiden codeschnipseln oben hat i++ i nicht bleibend verändert (*i)++ aber schon.

zu deiner ascii grafik:
würde das bedeuten, das zi++ (ja, zi ist bei mir ein zeiger) den zeiger auf einen anderen punkt im speicher zeigen lässt, er also nichtmehr auf i zeigt? (angenommen er hat vorher auf i gezeigt)

Ich gehe mal zuerst auf den zweiten Abschnitt ein:
nehmen wir an wir haben folgenden code:

int i = 1234;
int *zi = &i;

Dann speichert zi die Adresse von i.
Inkrementieren wir nun zi (also: zi++; bzw ++zi ergibt sich folgender Zusammenhang:
zi = &i + 1;
zi zeigt also auf die Adresse von i plus eins.

Zu deiner ersten Frage:
gehen wir wieder von der Funktion A aus meinem ersten Beispiel (eigentlich das weite, aber in meinem ersten post in diesem Topic...) aus, wobei wir mal der Einheitlichkeit zu liebe von einem Parameternamen zi ausgehen.
Es ergibt sich folgender Funktionsprototyp:
void A(int *zi);
zi ist also eine Variable mit dem Gültigkeitsbereich void A(int *), ist also nur innerhalb von A gültig und wird sich nach dem Rücksprung zum Aufrufer der Funktion wieder "auflösen", sprich seinen Wert verlieren.
Eine Inkrementation verändert also keine anderen Variablen, weil diese Variable (Zeiger auf i) einen eigenen Speicherbereich besitzt (welcher die Adresse von i enthält).
Dem zufolge verändert "zi++;" die Variable in der main-Funktion nicht.


mfG. BlackBerry

[Darkthief]

ok danke.
Das mit dem Gültigkeitsbereich hatte ich vergessen bzw. war mir da nie so sicher.

jetzt bleibt nurnoch meine Frage:
ist i++ dasselbe wie ++i ?

[-[RiDER]-]

Hi

Ich gehe mal zuerst auf den zweiten Abschnitt ein:
nehmen wir an wir haben folgenden code:

int i = 1234;
int *zi = &i;

Dann speichert zi die Adresse von i.
Inkrementieren wir nun zi (also: zi++; bzw ++zi ergibt sich folgender Zusammenhang:
zi = &i + 1;
zi zeigt also auf die Adresse von i plus eins.

Nope.

zi zeigt dann auf die Adresse von i plus sizeof(int) (wenn i wie bei Dir vom Typ int ist), also normalerweise vier.
Die Operation heißt also zi = &i + sizeof(int); oder in diesem Fall vielleicht sogar zi = &i + sizeof(i);, letzteres ist aber eher unwahrscheinlich...

jetzt bleibt nurnoch meine Frage:
ist i++ dasselbe wie ++i ?

Nein.

if(++i == i + 1)
  /* true, es wird zuerst das Inkrement ausgeführt und dann der Ausdruck überprüft */
if(i++ == i + 1)
  /* false, es findet zuerst die Überprüfung (i == i + 1) statt und dann das Inkrement */

Genauso gilt:

int i = 0, j = 0;
printf("%d", i++);  // liefert 0
printf("%d", ++j);  // liefert 1

GreetZ RiDER