Les pointeurs et les tableaux sont-ils différents en C?

J’écris un petit programme C pour effectuer des calculs, et il doit faire passer des tableaux entre les fonctions. Les fonctions doivent accepter et renvoyer des pointeurs, non?

Par exemple, ceci (je sais que ce n’est peut-être pas la chose la plus efficace):

int* reverse(int* l, int len) { int* reversed = malloc(sizeof(*reversed)*len); int i, j; for (i = 0, j = len-1; i < len; i++, j--) { reversed[j] = l[i]; } return reversed; } 

Est-ce que j’utilise des pointeurs, n’est-ce pas?

Votre extrait de code est correct. Cependant, les pointeurs et les tableaux en C sont en effet différents. Mettre simplement “le pointeur sur le type T” n’est pas la même chose que “le tableau de type T”.

Veuillez jeter un coup d’œil à C Faq pour discuter des pointeurs et des tableaux afin de mieux comprendre ceci.

Un lien vers C-FAQ: Tableaux et pointeurs a déjà été donné, mais il existe également une explication détaillée en C pour Smarties: Tableaux et pointeurs . Vous voudrez peut-être d’abord lire la page “Analyse d’expressions”.

Quelques choses à propos de votre exemple qui devraient être corrigées:

  1. Utilisation de int au lieu de size_t correct pour stocker les tailles d’object.
  2. Échec de la vérification de la valeur de retour de malloc() .

Une façon de “résoudre” ce second problème est de laisser l’appelant décider où la sortie est stockée (peut-être que l’appelant ne veut pas ou n’a pas besoin d’un tableau fraîchement alloué):

 int *reverse(int *out, int *l, size_t len) { size_t i, j; for (i = 0, j = len - 1; i < len; ++i, --j) { out[j] = l[i]; } return out; } 

Dans une perspective de bas niveau, un tableau est un bloc continu de mémoire auquel on accède par l’adresse du début de ce bloc et par le décalage. Ainsi, à partir de ce niveau d’abstraction, il s’agit d’un pointeur. Cependant, du sharepoint vue du langage C, un type de tableau est différent d’un type de pointeur. En principe, un tableau peut être affecté à une valeur de pointeur, mais ce n’est pas le même type .

Pour les besoins de votre fonction, vous vous en sortez bien.

Dans la théorie pédante, les tableaux et les pointeurs sont des choses différentes, puisqu’un tableau spécifie une région de mémoire et que la taille d’un tableau fait donc partie de son type. Donc, on dit qu’un nom de tableau se décompose en un pointeur lorsqu’il est utilisé dans ce contexte. Il y a une explication détaillée dans la C-FAQ .

En pratique, ils sont les mêmes car formellement a[i] est la même chose que *(a+i) , et donc le back-end du compilateur traite un nom de tableau et un pointeur de la même manière. La seule différence qui mérite d’être préoccupée est que

 void foo() { int a[5]; // allocates five words of space on the stack int *b; // allocates *one* word of space on the stack (to hold the pointer) } 

Votre extrait de code est correct. Veillez simplement à libérer la mémoire de votre fonction malloc() dans celui qui l’appelle.

les tableaux en C sont représentés et manipulés par un pointeur sur le premier élément, p.ex.

 int arr[50]; int * ptr1 = arr; int * ptr2 = &arr[0]; 

dans cet exemple, ptr1 == ptr2 car l’adresse du premier élément du tableau et le pointeur de base du tableau sont les mêmes.

Votre exemple de base est donc correct, bien que je soupçonne que le malloc devrait probablement être:

 int* reversed = malloc(sizeof(int)*len);