A propos des tableaux et des pointeurs

Question

Une brève question à faire surtout de comprendre comment les pointeurs fonctionnent avec des tableaux dans cet exemple:

char *lineptr[MAXLENGTH] 

Je comprends maintenant c'est le même que char **lineptr comme un tableau en lui-même est un pointeur.

Ma question est de savoir comment cela fonctionne dans ses différentes formes/états de-référencés tels que:

lineptr 
*lineptr 
**lineptr 
*lineptr[] 

Dans chacun de ces états, ce qu'il se passe, qu'est-ce que chaque Etat fait/travail dans le code?

Toute aide est très appréciée!

Answer 1

Maintenant, je comprends que c'est le même que char **lineptr comme un tableau en lui-même est un pointeur.

Non, un tableau n'est pas identique à un pointeur. Voir la FAQ C: http://c-faq.com/aryptr/index.html.

lineptr 

Ceci est le tableau lui-même. Dans la plupart des situations, il se désintègre en un pointeur vers son premier élément (c'est-à-dire &lineptr[0]). Donc, son type est soit int *[MAXLENGTH] ou int **.

*lineptr 

Ce déréférence le pointeur vers le premier élément, il est donc la valeur du premier élément (à savoir il est le même que lineptr[0]). Son type est int *.

**lineptr 

Ce déréférence les premiers éléments (à savoir, il est le même que *lineptr[0]). Son type est int.

*lineptr[] 

Je ne pense pas que ce soit une syntaxe valide (dans ce contexte).

Answer 2

lineptr est le/array/lui-même.

*lineptr est le premier élément du tableau, un char *

**lineptr est le produit de carbonisation pointée par le premier élément de la matrice

*lineptr[N] est le produit de carbonisation pointée par l'élément Nième de la matrice

Answer 3

Ok, les premières choses d'abord.

Les tableaux ne sont pas des pointeurs. Ils se décomposent simplement en pointeurs en cas de besoin. Considérez un tableau comme un pointeur qui contient déjà des données allouées/allouées.

---

lineptr: Ceci retourne simplement le tableau. Pas grand chose à dire.

*lineptr: Ceci revient à accéder au premier emplacement de votre baie. *lineptr = lineptr[0].Cela se produit simplement pour renvoyer un char *

**lineptr: Ceci accède au premier emplacement du tableau, puis déréférencé cet emplacement. **lineptr = *(lineptr[0]). Puisque votre tableau contient char* cela retournera le char stocké au char * dans l'emplacement 0 du tableau.

*lineptr[i]: Ceci déréférencie le char* stocké à i. Le char pointé par lineptr[i] est renvoyé.

Answer 4

Sauf quand il est l'opérande de l'sizeof ou unaire opérateur &, ou est une chaîne être littéral utilisé pour initialiser une autre matrice dans une déclaration, une expression de type « réseau de N éléments de T » sera remplacé par ("decay to") une expression de type "pointeur vers T", et la valeur de l'expression sera l'adresse du premier élément.

L'expression lineptr a le type "MAXLENGTH -element array de char *". Dans la plupart des cas, il sera remplacé par une expression de type char **. Voici une table à portée de main montrant toutes les possibilités:

 
Expression  Type     Decays to Evaluates to 
----------  ----     --------- ------------ 
    lineptr  char *[MAXLENGTH]  char ** address of first element in array 
&lineptr  char *(*)[MAXLENGTH] n/a  address of array 
*lineptr  char *    n/a  value of first element 
    lineptr[i] char *    n/a  value of i'th element 
&lineptr[i] char **    n/a  address of i'th element 
*lineptr[i] char     n/a  value of character pointed to by i'th element 
**lineptr  char     n/a  value of character pointed to by zero'th element 

Notez que lineptr et &lineptr ÉVALUER à la même valeur (l'adresse d'un tableau est le même que l'adresse de son premier élément), mais leurs types sont différent (char ** contre char *(*)[MAXLENGTH]).