Pointeur C vers tableau / tableau de pointeurs désambiguïsation

Quelle est la différence entre les déclarations suivantes:

int* arr1[8];
int (*arr2)[8];
int *(arr3[8]);

Quelle est la règle générale pour comprendre des déclarations plus complexes?

int* arr[8]; // An array of int pointers.
int (*arr)[8]; // A pointer to an array of integers

Le troisième est le même que le premier.

La règle générale est la priorité des opérateurs . Cela peut devenir encore plus complexe lorsque des pointeurs de fonction apparaissent dans l'image.

Utilisez le programme cdecl , comme suggéré par K&R.

$ cdecl
Type `help' or `?' for help
cdecl> explain int* arr1[8];
declare arr1 as array 8 of pointer to int
cdecl> explain int (*arr2)[8]
declare arr2 as pointer to array 8 of int
cdecl> explain int *(arr3[8])
declare arr3 as array 8 of pointer to int
cdecl>

Cela fonctionne aussi dans l'autre sens.

cdecl> declare x as pointer to function(void) returning pointer to float
float *(*x)(void )

Je ne sais pas s'il a un nom officiel, mais je l'appelle Thingy Droite-Gauche (TM).

Commencez par la variable, puis allez à droite, à gauche, à droite ... et ainsi de suite.

int* arr1[8];

arr1 est un tableau de 8 pointeurs vers des entiers.

int (*arr2)[8];

arr2 est un pointeur (la parenthèse bloque la droite-gauche) sur un tableau de 8 entiers.

int *(arr3[8]);

arr3 est un tableau de 8 pointeurs vers des entiers.

Cela devrait vous aider avec des déclarations complexes.

int *a[4]; // Array of 4 pointers to int

int (*a)[4]; //a is a pointer to an integer array of size 4

int (*a[8])[5]; //a is an array of pointers to integer array of size 5 

La réponse pour les deux derniers peut également être déduite de la règle d'or en C:

La déclaration suit l'utilisation.

int (*arr2)[8];

Que se passe-t-il si vous déréférencez arr2? Vous obtenez un tableau de 8 entiers.

int *(arr3[8]);

Que se passe-t-il si vous prenez un élément arr3? Vous obtenez un pointeur sur un entier.

Cela aide également lorsque vous traitez des pointeurs vers des fonctions. Pour prendre l'exemple de sigjuice:

float *(*x)(void )

Que se passe-t-il lorsque vous déréférencez x? Vous obtenez une fonction que vous pouvez appeler sans arguments. Que se passe-t-il lorsque vous l'appelez? Il renverra un pointeur sur a float.

La priorité des opérateurs est cependant toujours délicate. Cependant, l'utilisation de parenthèses peut également être source de confusion car la déclaration suit l'utilisation. Au moins, pour moi, cela arr2ressemble intuitivement à un tableau de 8 pointeurs vers des pouces, mais c'est en fait l'inverse. Il suffit de s'y habituer. Raison suffisante pour toujours ajouter un commentaire à ces déclarations, si vous me demandez :)

modifier: exemple

Soit dit en passant, je suis juste tombé sur la situation suivante: une fonction qui a une matrice statique et qui utilise l'arithmétique du pointeur pour voir si le pointeur de ligne est hors limites. Exemple:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define NUM_ELEM(ar) (sizeof(ar) / sizeof((ar)[0]))

int *
put_off(const int newrow[2])
{
    static int mymatrix[3][2];
    static int (*rowp)[2] = mymatrix;
    int (* const border)[] = mymatrix + NUM_ELEM(mymatrix);

    memcpy(rowp, newrow, sizeof(*rowp));
    rowp += 1;
    if (rowp == border) {
        rowp = mymatrix;
    }

    return *rowp;
}

int
main(int argc, char *argv[])
{
    int i = 0;
    int row[2] = {0, 1};
    int *rout;

    for (i = 0; i &lt; 6; i++) {
        row[0] = i;
        row[1] += i;
        rout = put_off(row);
        printf("%d (%p): [%d, %d]\n", i, (void *) rout, rout[0], rout[1]);
    }

    return 0;
}

Production:

0 (0x804a02c): [0, 0]
1 (0x804a034): [0, 0]
2 (0x804a024): [0, 1]
3 (0x804a02c): [1, 2]
4 (0x804a034): [2, 4]
5 (0x804a024): [3, 7]

Notez que la valeur de border ne change jamais, donc le compilateur peut optimiser cela. Ceci est différent de ce que vous voudrez peut-être utiliser initialement const int (*border)[3]:: qui déclare border comme pointeur vers un tableau de 3 entiers qui ne changera pas de valeur tant que la variable existe. Cependant, ce pointeur peut être pointé vers n'importe quel autre tableau de ce type à tout moment. Nous voulons plutôt ce type de comportement pour l'argument (car cette fonction ne modifie aucun de ces entiers). La déclaration suit l'utilisation.

(ps: n'hésitez pas à améliorer cet échantillon!)

typedef int (*PointerToIntArray)[];
typedef int *ArrayOfIntPointers[];

En règle générale, opérateurs unaires à droite (comme [], (), etc.) donnent leur préférence sur les gauche. Donc, ce int *(*ptr)()[];serait un pointeur qui pointe vers une fonction qui renvoie un tableau de pointeurs à int (obtenez les bons opérateurs dès que vous le pouvez en sortant de la parenthèse)

Je pense que nous pouvons utiliser la règle simple ..

example int * (*ptr)()[];
start from ptr 

" ptrest un pointeur vers" aller vers la droite .. ses ")" maintenant aller vers la gauche c'est un "(" sortir sortir vers la droite "()" donc "vers une fonction qui ne prend aucun argument" aller vers la gauche "et retourner un pointeur" aller à droite "vers un tableau" aller à gauche "d'entiers"

Voici un site Web intéressant qui explique comment lire des types complexes en C: http://www.unixwiz.net/techtips/reading-cdecl.html

Voici comment je l'interprète:

int *something[n];

Remarque sur la priorité: l'opérateur d'indice de tableau ( []) a une priorité plus élevée que l'opérateur de déréférence ( *).

Donc, ici, nous appliquerons l' []avant *, ce qui rend la déclaration équivalente à:

int *(something[i]);

Remarque sur le sens d'une déclaration: int nummoyens numest unint , int *ptrou int (*ptr)moyens, (valeur at ptr) est un int, qui fait ptrun pointeur vers int.

Cela peut être lu comme, (la valeur de la (valeur au ième index du quelque chose)) est un entier. Ainsi, (valeur au ième index de quelque chose) est un (pointeur entier), ce qui fait de quelque chose un tableau de pointeurs entiers.

Dans le second,

int (*something)[n];

Pour donner un sens à cette déclaration, vous devez être familier avec ce fait:

Remarque sur la représentation du pointeur du tableau: somethingElse[i]équivaut à*(somethingElse + i)

Donc, en remplaçant somethingElsepar (*something), nous obtenons *(*something + i), qui est un entier selon la déclaration. Donc, (*something)nous a donné un tableau, ce qui fait quelque chose d'équivalent à (pointeur vers un tableau) .

Je suppose que la deuxième déclaration prête à confusion pour beaucoup. Voici un moyen simple de le comprendre.

Permet d'avoir un tableau d'entiers, c'est à dire int B[8].

Ayons également une variable A qui pointe vers B. Maintenant, la valeur en A est B, c'est-à-dire (*A) == B. Par conséquent, A pointe vers un tableau d'entiers. Dans votre question, arr est similaire à A.

De même, dans int* (*C) [8], C est un pointeur vers un tableau de pointeurs sur entier.

int *arr1[5]

Dans cette déclaration, arr1est un tableau de 5 pointeurs vers des entiers. Motif: les crochets ont une priorité plus élevée que * (opérateur de déréfernçage). Et dans ce type, le nombre de lignes est fixe (5 ici), mais le nombre de colonnes est variable.

int (*arr2)[5]

Dans cette déclaration, arr2est un pointeur vers un tableau entier de 5 éléments. Raison: ici, les crochets () ont une priorité plus élevée que []. Et dans ce type, le nombre de lignes est variable, mais le nombre de colonnes est fixe (5 ici).

Dans le pointeur vers un entier si le pointeur est incrémenté, il passe à l'entier suivant.

dans le tableau du pointeur si le pointeur est incrémenté, il passe au tableau suivant