C pointeur sur tableau/Tableau d’homonymie de pointeurs

Question

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

Quelle est la règle générale permettant de comprendre les déclarations plus complexes ?

Answer 1

<pre><code></code><p>Le troisième argument est identique à la première.</p><p><a href="http://unixwiz.net/techtips/reading-cdecl.html">précédence des opérateurs</a>. Il peut même devenir beaucoup plus complexe comme des pointeurs fonction viennent dans l’image.</p></pre>

Answer 2

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

Ça marche l’autre beaucoup trop.

Answer 3

Je ne sais pas si elle a un nom officiel, mais je l'appelle le Droit-Gauche "Truc" (TM).

Commencer à la variable, puis aller à droite et à gauche, et à 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 bloc de droite à gauche) à un tableau de 8 entiers.

int *(arr3[8]);

arr3 est un tableau de 8 pointeurs vers des entiers.

Cela devrait vous aider, avec le complexe des déclarations.

Answer 4

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 

Answer 5

La réponse pour les deux derniers peuvent également être déduit de la règle d'or dans C:

Déclaration d'utilisation.

int (*arr2)[8];

Qu'advient-il si vous déréférencement de arr2? Vous obtenez un tableau de 8 entiers.

int *(arr3[8]);

Ce qui se passe si vous prenez un élément de arr3? Vous obtenez un pointeur vers un entier.

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

float *(*x)(void )

Ce qui se passe quand vous déréférencement de x? Vous obtenez une fonction que vous pouvez appeler sans arguments. Ce qui se passe quand vous l'appelez? Il retournera un pointeur sur un char.

La priorité de l'opérateur est toujours délicat, si. Cependant, l'utilisation de parenthèses peuvent aussi être source de confusion en raison de la déclaration suivante de l'utilisation. Au moins, pour moi, intuitivement arr2 ressemble à un tableau de 8 pointeurs vers des entiers, mais il est en fait l'inverse. Faut juste un peu s'y habituer. Une raison suffisante pour toujours ajouter un commentaire à ces déclarations, si vous me demandez :)

edit: exemple

En passant, j'ai juste trébuché à travers la situation suivante: une fonction statique de la matrice et qui utilise l'arithmétique des pointeurs pour voir si le pointeur de la 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 < 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;
}

Sortie:

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 frontière ne change jamais, de sorte que le compilateur peut optimiser tout ça. C'est différent de ce que vous voulez d'abord utiliser: const int (*border)[3]: qui déclare la frontière comme un pointeur vers un tableau de 3 entiers qui ne changera pas de valeur tant que la variable existe. Cependant, ce pointeur peut être rappelé à tout autre tableau à tout moment. Nous voulons que ce genre de comportement pour l'argument, au lieu (parce que cette fonction ne modifie en aucune façon les entiers). Déclaration d'utilisation.

(p.s.: n'hésitez pas à améliorer cet exemple!)