Est-il mauvais de se référer aux éléments du tableau d'accès via l'arithmétique du pointeur au lieu de l'opérateur []?

Je viens de commencer à apprendre à programmer en C, et pour améliorer ma compréhension des pointeurs et des tableaux, j'ai essayé de faire référence aux éléments d'un tableau sans créer de pointeur du tout:

for(k1 = 0; k1 < ROW; k1++){
    for(k2 = 0; k2 < COLUMN; k2++){

        array[k1][k2] = k1*COLUMN + k2 + 1;

        printf("[%d][%d] = %d\n", k1, k2, *(array[k1] + k2));

    }
}

Le code entier se compile et fonctionne parfaitement.

J'imagine avoir à créer un pointeur pour chaque tableau unique dans un gros code source semble être très inefficace.

Donc, plutôt que d'avoir l'adresse d'un tableau stockée et récupérée à l'aide d'un pointeur, est-ce une mauvaise pratique de programmation d'utiliser directement l'adresse du tableau, comme indiqué ci-dessus?

C'est "mauvais" seulement dans la mesure où c'est moins lisible. a[x]est la même chose que *(a+x), donc il n'y a pas de différence d'efficacité ou de comportement (en fait, ça x[a]marche aussi). C'est juste que a[x]c'est généralement beaucoup plus intuitif pour nous les humains.

Mais cela ne veut pas dire que la lisibilité n'est pas un gros problème. Pour voir leur taille, pensez à la façon dont vous "liriez" ces deux expressions si vous les voyiez dans le code:

• *(a+x)= "Le machin pointé par la somme du pointeur aet de l'entier x"
• a[x]= "Le xe membre du tableau a"

De même, lorsque vous devez vous référer à l'adresse d'un élément de tableau:

• (a+x)= "La somme du pointeur aet de l'entier x"
• &a[x]= "L'adresse du xe membre du tableau a"

La plupart du temps, les []versions sont simplement plus faciles à comprendre lorsque vous regardez du code non trivial fonctionnant sur plusieurs tableaux différents (en particulier des tableaux de tableaux). C'est pourquoi l' []opérateur existe en premier lieu.

PS Faire ce genre de chose strictement comme un exercice d'apprentissage est une très bonne idée. Il est important de comprendre que les tableaux ne sont en réalité que des pointeurs et des décalages.

Oui, c'est une mauvaise pratique, mais pas pour des raisons d'inefficacité.

L'opérateur de tableau utilise un pointeur arithmétique sous le capot, ils sont donc tout aussi efficaces.

Le problème avec l'arithmétique du pointeur est qu'il est très sujet aux erreurs et plus difficile à lire.

Règle générale: n'utilisez pas l'arithmétique de pointeur sauf si vous le devez.

Cool votre apprentissage c, vous venez de découvrir l'un des petits virelangues c. Vous ne faites pas de l'arithmétique des pointeurs sur un tableau, mais un tableau de pointeurs. Il n'est pas possible d'effectuer l'arithmétique du pointeur sur les tableaux. Un tableau se désintègre en un pointeur mais n'est pas un type de pointeur lui-même. Ce que vous avez (voir le commentaire de cmaster) est

int *array[]; //This is a array to pointers of type *int. 

array[k1] + k2; //This is pointer arithmetic on one pointer stored in the array  

Le déréférencement de ce pointeur donne la valeur vers laquelle votre pointeur vient d'être calculé. Il est généralement inutile de faire ce que vous faites. Mais vous pouvez linéariser le tableau puis une foulée, comme ceci.

int array[y_dim*x_dim]; 
int index = x_dim*y + x; 
array[index]; //Gives you the element in x, y!

La fouler est x_dim. J'espère que ma réponse clarifie!