Hello Laurence,

Friday, August 9, 2002, 2:16:42 PM, you wrote:


LT> Das ist ja alles noch recht einfach. Wenn ich aber jetzt z.B. einen

LT> const char** p

LT> habe, weiß ich nicht mehr welches der Dinge jetzt const ist und welches
LT> nicht...

a) const char *string;
b) char *const string;
c) const char *const string;

Erklärung:
a) Zeiger auf ein Char-Datentyp, das als konstant markiert worden ist,
   d.h. der Datentyp auf den der Zeiger zeigt darf *nicht* verändert
   werden, der Zeiger aber schon.
   Beispiel:
             string++;   /* erlaubt, da hier der     */
                         /* Zeiger verändert wird    */
             *(string)++ /* ist jedoch nicht erlaubt */

b) Konstanter Zeiger auf einen Datentyp Char, d.h. der Zeiger *muss*
   immer auf genau *diesen* Datentyp zeigen, und darf nicht verändert
   werden; der Datentyp jedoch schon!
   Beispiel:
             string++;   /* nicht erlaubt, da hier      */
                         /* versucht wird zu verändern  */
                         /* worauf `string' zeigen soll */
             *(string)++ /* völlig legitim!             */

c) Konstanter Zeiger auf konstanten Datentyp, aus den zwei Beispielen
   von oben, resultiert deshalb folgendes daraus:

   string++;    /* nicht erlaubt      */
   *(string)++; /* auch nicht erlaubt */


LT> Oder wie wär's zum Beispiel mit

LT> int ** i[10](int*(int)) ????

Ok, stückeln wir das mal auf:

int i[10]           == Int-Array mit maximal 10 Einträgen.

int * i[10]         == Zeiger auf ein Int-Array mit maximal 10 Einträgen.

int **i[10]         == Zeiger auf eine Speicherstelle, die wiederum
                       ein Zeiger auf ein Int-Array mit maximal 10
                       Einträgen darstellt.
                       
int i[10](int *int) == Int-Array, das 10 Funktionen inne hält, die
                       ein einzelnes Argument benötigen, nämlich jeweils
                       einen Zeiger auf einen Int-Datentyp.

========================================================================
Ergebnis: int * i[10] == Ein Int-Zeiger auf eine Speicherstelle (der
                         größe int), die wiederum auf ein Array des
                         Datentyps Int zeigt, das maximal 10
                         Funktionen enthalten kann, welche jeweils
                         einen Zeiger auf einen Int-Datentyp als
                         Argument benötigen.

Alles klar?


LT> laurence
--
cheers,
  Tobias

----------------------------------------------------------------------------
PUG - Penguin User Group Wiesbaden - http://www.pug.org

Antwort per Email an