Initialisation des tableaux de pointeurs en C

Salut à toi, futurs superstars du codage ! Aujourd'hui, nous allons plonger dans le monde fascinant des tableaux de pointeurs en C. Ne t'inquiète pas si tu es nouveau dans le domaine de la programmation - je vais te guider pas à pas, comme j'ai fait pour des centaines d'étudiants au fil des ans. Alors, prends une tasse de ta boisson favorite et partons ensemble dans cette aventure passionnante !

Comment initialiser un tableau de pointeurs en C ?

Avant de rentrer dans les détails de l'initialisation des tableaux de pointeurs, reprenons rapidement ce qu'est un pointeur. Imagine les pointeurs comme des pancartes indicateurs qui pointent vers des emplacements dans la mémoire de ton ordinateur. Lorsque nous parlons d'un tableau de pointeurs, il s'agit d'une rangée de pancartes indicateurs, chacune pointant vers un emplacement différent.

Commençons par un exemple simple :

int *ptr_array[5];

Cette ligne déclare un tableau de 5 pointeurs vers des entiers. Mais attention ! Nous avons seulement créé les pancartes indicateurs ici, pas les données auxquelles elles pointent. C'est comme installer des pancartes vides dans une nouvelle ville - elles existent, mais elles ne pointent vers rien de utile encore.

Pour rendre notre tableau de pointeurs réellement utile, nous devons l'initialiser. Voici comment nous pouvons le faire :

int a = 10, b = 20, c = 30, d = 40, e = 50;
int *ptr_array[5] = {&a, &b, &c, &d, &e};

Dans cet exemple, nous avons créé cinq variables entières, puis initialisé notre tableau de pointeurs pour qu'il pointe vers ces variables. C'est comme si nous avions finalement écrit des destinations sur nos pancartes indicateurs !

Initialisation d'un tableau de pointeurs avec le mot-clé static

Passons maintenant au mot-clé static. En C, static est comme un mot magique qui garde les variables vivantes tout au long de la vie du programme. Lorsque nous utilisons static avec notre tableau de pointeurs, cela garantit que le tableau est initialisé une seule fois et conserve sa valeur entre les appels de fonction.

Voici un exemple :

static int *ptr_array[3] = {NULL, NULL, NULL};

Cela crée un tableau statique de trois pointeurs vers des entiers, tous initialement pointant vers NULL. C'est comme installer trois pancartes permanentes dans notre ville, mais nous ne savons pas encore où elles devraient pointer.

Initialisation d'un tableau de pointeurs vers des entiers

Passons à l'aspect pratique. Supposons que nous voulons créer un tableau de pointeurs, chacun pointant vers un entier différent. Voici comment nous pouvons le faire :

int num1 = 10, num2 = 20, num3 = 30;
int *int_ptr_array[3] = {&num1, &num2, &num3};

for (int i = 0; i < 3; i++) {
printf("Valeur à l'index %d: %d\n", i, *int_ptr_array[i]);
}

Dans ce code, nous créons trois entiers et un tableau de pointeurs qui pointent vers ces entiers. Ensuite, nous utilisons une boucle for pour imprimer les valeurs. C'est comme si nous avions installé trois pancartes dans notre ville, chacune pointant vers une maison avec un numéro différent, et puis nous faisons un tour de la ville pour lire tous les numéros de maison !

Initialisation d'un tableau de pointeurs par des adresses directes

Parfois, nous pouvons vouloir initialiser notre tableau de pointeurs avec des adresses mémoire directes. Bien que cela soit moins courant, il est bon de savoir comment cela fonctionne :

int *direct_addr_array[3] = {(int*)100, (int*)200, (int*)300};

for (int i = 0; i < 3; i++) {
printf("Adresse dans direct_addr_array[%d]: %p\n", i, (void*)direct_addr_array[i]);
}

Ici, nous initialisons notre tableau avec des adresses mémoire spécifiques. C'est comme si nous avions installé nos pancartes pour pointer vers des coordonnées GPS spécifiques dans notre ville. Sois prudent avec cette approche cependant - pointer vers des adresses mémoire arbitraires peut être dangereux si tu ne sais pas exactement ce que tu fais !

Parcourir un tableau avec son adresse de base

Apprenons maintenant un astuce sympa. Nous pouvons utiliser l'arithmétique des pointeurs pour parcourir un tableau en utilisant uniquement son adresse de base. Voici comment :

int numbers[5] = {10, 20, 30, 40, 50};
int *base_ptr = numbers;  // base_ptr pointe maintenant vers le premier élément de numbers

for (int i = 0; i < 5; i++) {
printf("Valeur à l'index %d: %d\n", i, *(base_ptr + i));
}

Dans cet exemple, base_ptr pointe vers le premier élément de notre tableau numbers. En ajoutant i à base_ptr, nous pouvons accéder à chaque élément du tableau. C'est comme avoir une pancarte magique qui peut pointer vers n'importe quelle maison dans notre ville en lui disant simplement combien de pas à faire !

Initialisation d'un tableau de pointeurs vers des caractères (chaînes)

Les tableaux de pointeurs vers des caractères sont couramment utilisés pour stocker des chaînes en C. Voici un exemple :

char *fruits[] = {"Apple", "Banana", "Cherry", "Date", "Elderberry"};

for (int i = 0; i < 5; i++) {
printf("Fruit %d: %s\n", i+1, fruits[i]);
}

Dans ce code, nous créons un tableau de pointeurs vers des chaînes littérales. C'est comme si nous avions installé des pancartes dans le marché agricole de notre ville, chacune pointant vers un stand de fruits différent !

Initialisation d'un tableau de pointeurs dynamique

Enfin, parlons de l'allocation dynamique de notre tableau de pointeurs. Cela est utile lorsque nous ne connaissons pas la taille de notre tableau au moment de la compilation :

int n = 3;  // Nous pouvons changer cette valeur à l'exécution
int **dynamic_ptr_array = (int**)malloc(n * sizeof(int*));

for (int i = 0; i < n; i++) {
dynamic_ptr_array[i] = (int*)malloc(sizeof(int));
*dynamic_ptr_array[i] = i * 10;
}

for (int i = 0; i < n; i++) {
printf("Valeur à dynamic_ptr_array[%d]: %d\n", i, *dynamic_ptr_array[i]);
}

// N'oublie pas de libérer la mémoire allouée !
for (int i = 0; i < n; i++) {
free(dynamic_ptr_array[i]);
}
free(dynamic_ptr_array);

C'est comme construire un nouveau quartier dans notre ville à la demande. Nous créons d'abord les pancartes (dynamic_ptr_array), puis pour chaque pancarte, nous construisons une maison (malloc(sizeof(int))) et mettons un numéro dedans (i * 10). Une fois que nous avons fini d'utiliser notre quartier, nous nous assurons de nettoyer en libérant la mémoire allouée.

Et voilà, amis ! Nous avons traversé le pays des tableaux de pointeurs en C. Souviens-toi, la pratique rend parfait, donc n'hésite pas à expérimenter avec ces concepts. Bon codage !

Méthode	Description	Exemple
Initialisation de base	Initialiser un tableau de pointeurs avec les adresses de variables	int *ptr_array[5] = {&a, &b, &c, &d, &e};
Initialisation statique	Initialiser un tableau statique de pointeurs	static int *ptr_array[3] = {NULL, NULL, NULL};
Tableau de pointeurs vers des entiers	Initialiser un tableau de pointeurs vers des entiers	int *int_ptr_array[3] = {&num1, &num2, &num3};
Initialisation par adresses directes	Initialiser un tableau avec des adresses mémoire directes	int *direct_addr_array[3] = {(int*)100, (int*)200, (int*)300};
Parcourir par l'adresse de base	Parcourir un tableau en utilisant son adresse de base	int *base_ptr = numbers;
Tableau de pointeurs vers des caractères	Initialiser un tableau de pointeurs vers des chaînes (strings)	char *fruits[] = {"Apple", "Banana", "Cherry"};
Allocation dynamique	Allocation dynamique d'un tableau de pointeurs	int **dynamic_ptr_array = (int**)malloc(n * sizeof(int*));

Credits: Image by storyset