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:
Code:
+----+
|    |
| &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...