Comprendre la relation complexe entre les pointeurs et les tableaux en C peut être déroutant pour les développeurs.
Une mauvaise compréhension peut entraîner des erreurs de gestion de mémoire, rendant le code inefficace et difficile à maintenir.
Cet article décompose la relation entre pointeurs et tableaux, offrant des explications claires et des exemples pratiques pour les maîtriser.
Développez votre expertise en C et ouvrez la voie à des projets passionnants.
Pointeurs et tableaux en C : le lien
Un tableau et un pointeur en C sont étroitement liés dans la façon dont ils accèdent à la mémoire. Le nom d’un tableau est essentiellement un pointeur constant qui représente l’adresse du premier élément du tableau. Cela signifie que, dans de nombreux cas, un tableau peut être manipulé comme un pointeur.
Relation de base : tableaux en C
Quand vous déclarez un tableau comme :
int tableau[5] = {10, 20, 30, 40, 50};
Le nom tableau est traité par le compilateur comme l’adresse du premier élément du tableau, c’est-à-dire &tableau[0].
Ainsi, l’instruction suivante :
int *p = tableau;
est équivalente à :
int *p = &tableau[0];
Cela signifie que le pointeur p pointe vers l’adresse du premier élément du tableau , tout comme le fait tableau lui-même. Il n’y a donc pas de différence fondamentale entre l’utilisation d’un tableau et d’un pointeur dans ce contexte, sauf que le nom du tableau est un pointeur constant (il ne peut pas être modifié pour pointer ailleurs), tandis qu’un pointeur ordinaire peut être redirigé vers d’autres adresses.
Accès aux éléments avec un pointeur
L’arithmétique des pointeurs peut être utilisée pour accéder aux éléments d’un tableau. Par exemple :
*(tableau + 2) // équivalent à tableau[2]
Opération | Signification |
|---|---|
tableau[i] | Accède à l’élément d’indice i |
*(tableau + i) | Accède à l’adresse décalée de i |
Example :
#include <stdio.h>
int main() {
int tableau[5] = {10, 20, 30, 40, 50};
int *p = tableau;
printf("tableau[2] : %d\n", tableau[2]);
printf("tableau[2] : %d\n", *(p + 2));
// Affiche également 30
return 0;
}
Dans ces deux cas, nous accédons à la troisième position du tableau (index 2). L’expression *(p + 2) est le résultat de la somme de l’adresse pointée par p (qui est celle du premier élément du tableau) et le déplacement de deux positions en mémoire (dû au type int, chaque position représente 4 octets sur une architecture 32 bits).
- Example d’exaction du code sur Eclipse
Arithmétique des pointeurs
L’arithmétique des pointeurs permet de parcourir un tableau à l’aide d’un pointeur. En augmentant ou en diminuant la valeur du pointeur, vous vous déplacez dans le tableau.
Voici un exemple d’arithmétique des pointeurs :
#include <stdio.h>
int main() {
int tableau[5] = {10, 20, 30, 40, 50};
int *p = tableau;
for (int i = 0; i < 5; i++) {
printf("Élément %d : %d\n", i, *(p + i));
// Utilisation de l'arithmétique des pointeurs
}
return 0;
}
déplacent le pointeur de 1 ou 2 positions, respectivement, dans le tableau. Notez que le déplacement dépend du type des éléments du tableau. Si vous avez un tableau de float ou de char, l’incrémentation du pointeur se fera par les tailles des types respectifs (4 octets pour un float, 1 octet pour un char).
- Example d’exaction du code sur Eclipse
Différences : tableaux vs pointeurs C
Aspect | Tableau | Pointeur |
|---|---|---|
Allocation mémoire | Un tableau est une zone contiguë de mémoire allouée à la compilation (variable locale ou globale). | Un pointeur peut être redirigé vers différentes zones de mémoire au cours du programme (via l’allocation dynamique par exemple). |
Modifiabilité | Le nom d’un tableau est constant et ne peut pas être modifié pour pointer ailleurs. | Un pointeur peut être redirigé vers différentes adresses. |
Taille | L’opérateur sizeof appliqué à un tableau renvoie la taille totale du tableau. (Ex: sizeof(tableau) retourne 20 octets pour un tableau d’entiers de 5 éléments sur une machine 32 bits). | L’opérateur sizeof appliqué à un pointeur renvoie la taille de l’adresse qu’il contient (4 ou 8 octets selon l’architecture). |
Exemple du code :
#include <stdio.h>
int main() {
int tableau[5] = {10, 20, 30, 40, 50};
int *p = tableau;
printf("Taille du tableau : %lu\n", sizeof(tableau));
// Affiche 20
printf("Taille du pointeur : %lu\n", sizeof(p));
// Affiche 4 ou 8
return 0;
}
- Example d’exaction du code sur Eclipse
Fonctions en C : pointeurs et tableaux
Lorsque vous passez un tableau à une fonction en C, ce n’est en réalité qu’un pointeur vers le premier élément qui est passé. Cela signifie que les fonctions peuvent modifier les éléments du tableau en modifiant les valeurs via ce pointeur.
Exemple :
#include <stdio.h>
void modifierTableau(int *p) { p[0] = 100; }
int main() {
int tableau[5] = {10, 20, 30, 40, 50};
modifierTableau(tableau);
printf("%d\n", tableau[0]);
// Affiche 100
return 0;
}
Ici, la fonction modifierTableau reçoit un pointeur sur le tableau et peut modifier directement son contenu.
- Example d’exaction du code sur Eclipse
Arithmétique : tableaux multidimensionnels C
Un tableau multidimensionnel est un tableau de tableaux. Par exemple, un tableau 2D est une collection de tableaux 1D. Il est important de comprendre que, dans ce cas, chaque « ligne » est un tableau et a également une adresse.
- Prenons un tableau 2D :
int tableau2D[3][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
L’accès à un élément spécifique se fait via deux indices, par exemple :
int val = tableau2D[1][2];
// Accède à l'élément 7
Vous pouvez aussi utiliser des pointeurs pour accéder aux éléments d’un tableau 2D en les traitant comme un tableau 1D d’adresses :
int *p = &tableau2D[0][0];
int val = *(p + 5);
// Accède à l'élément 6
Le pointeur p pointe sur le premier élément de tableau2D, et l’arithmétique des pointeurs permet de parcourir tout le tableau en mémoire.
#include <stdio.h>
int main() {
// Déclaration d'un tableau 2D de 3 lignes et 4 colonnes
int tab[3][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
// Pointeur vers un tableau de 4 entiers (les colonnes du tableau 2D)
int(*ptr)[4] = tab;
// Affichage du tableau en utilisant le pointeur
printf("Affichage des éléments du tableau 2D via le pointeur :\n");
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 4; j++) {
// Accès aux éléments via le pointeur
printf("%d ", ptr[i][j]);
}
printf("\n");
}
// Utilisation de l'arithmétique des pointeurs pour accéder aux éléments
printf("\nUtilisation de l'arithmétique des pointeurs :\n");
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 4; j++) {
// *(ptr + i) pointe vers la ième ligne, et + j permet d'accéder à la jème
// colonne
printf("%d ", *(*(ptr + i) + j));
}
printf("\n");
}
return 0;
}
- Example d’exaction du code sur Eclipse
Expression | Interprétation | Résultat |
|---|---|---|
tableau[i] | Accès à l’élément i du tableau | Équivalent à *(tableau + i) |
&tableau[i] | Adresse de l’élément i du tableau | |
*(tableau + i) | Valeur à l’adresse tableau + i | |
tableau | Pointeur constant vers tableau [0] | |
sizeof(tableau) | Taille totale du tableau | Différent de sizeof(p) où p est un pointeur |
Conclusion sur pointeurs et tableaux C
À travers ce chapitre, nous avons exploré le lien entre les pointeurs et les tableaux en C, en montrant comment les pointeurs permettent d’accéder directement aux éléments d’un tableau. Il est essentiel de bien comprendre ces concepts pour gérer efficacement la mémoire dans les programmes C.
Formez-vous gratuitement avec Alphorm !
Maîtrisez les compétences clés en IT grâce à nos formations gratuites et accélérez votre carrière dès aujourd'hui.
FAQ
Quelle est la relation entre un tableau et un pointeur en langage C ?
Comment accéder aux éléments d'un tableau avec des pointeurs ?
Quelles sont les différences entre un tableau et un pointeur ?
Comment les pointeurs sont-ils utilisés avec des fonctions en C ?
Comment utiliser les pointeurs pour les tableaux multidimensionnels ?
Conclusion
En comprenant la relation entre les pointeurs et les tableaux en C, on peut manipuler efficacement la mémoire dans les programmes. Quels autres aspects des pointeurs souhaitez-vous explorer pour renforcer vos compétences en C ?
