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