Structures et pointeurs en C

Dans ce tutoriel, vous apprendrez à accéder aux membres des structures en utilisant des pointeurs en langage C. Vous apprendrez également à allouer dynamiquement de la mémoire pour des types de structures.

Avant de comprendre comment utiliser les pointeurs avec les structures, veuillez lire le tutoriel suivant :

• Pointeurs en C

• Structure

Pointeur vers structure en C

Voici la méthode pour créer un pointeur de structure.

struct name {
　　　　membre1;
　　　　membre2;
　　　　.
　　　　.
};
int main()
{
　　　　struct name　*ptr, Harry;
}

Ici, ptr est un pointeur vers une structure.

Exemple : accéder aux membres à l'aide de pointeurs

Pour accéder aux membres de la structure à l'aide de pointeurs, nous utilisons-> opérateur.

#include　<stdio.h>
struct personne
{
　　　int age;
　　　float poids;
};
int main()
{
　　　　struct personne　*personPtr, person1;
　　　　personPtr = &person1;　　　
　　　　printf("Entrer l'âge: \t");
　　　　scanf("%d", &personPtr->age);
　　　　printf("Entrer le poids: \t");
　　　　scanf("%f", &personPtr->poids);
　　　　printf("Affichage:\n");
　　　　printf("Âge: \t%d\n", personPtr->age);
　　　　printf("Poids:　%f",　personPtr)->poids);
　　　　return 0;
}

Résultat de la sortie

Saisir l'âge:　25
Saisir le poids:　55
Affichage:
Âge:　25
Poids:　55.000000

Dans cet exemple, utiliser personPtr =＆person1;Stocker person1L'adresse est stockée dans le pointeur personPtr.

Maintenant, vous pouvez accéder à person avec le pointeur personPtr1des membres.

En passant

• personPtr->age est équivalent à (*personPtr).age

• personPtr->poids est équivalent à (*personPtr).poids

L'allocation dynamique de mémoire des structures

Avant de continuer cette section, il est recommandé de vérifierAllocation dynamique de mémoire C.

Parfois, le nombre de variables struct que vous declarez peut ne pas être suffisant. Vous pourriez devoir allouer de la mémoire au cours de l'exécution. Voici comment vous pouvez réaliser cet objectif en programmation C.

Exemple : allocation dynamique de mémoire pour les structures

#include　<stdio.h>
#include　<stdlib.h>
struct personne {
　　　int age;
　　　float poids;
　　　char name[30];
};
int main()
{
　　　struct personne　*ptr;
　　　int i, n;
　　　printf("Nombre d'entrées:　");
　　　scanf("%d",　&n);
　　　//Allouer de la mémoire pour n struct　personne
　　　ptr = (struct person*) malloc(n　*　sizeof(struct person));
　　　for(i = 0;　i < n;　++i)
　　　{
　　　　　　　printf("Saisir respectivement le nom et l'âge:　");
　　　　　　　　　//Pour accéder aux membres de la première struct　personne,
　　　　　　　　　//On peut utiliser ptr->name et ptr->age
　　　　　　　　//Pour accéder aux membres de la deuxième struct　personne,
　　　　　　　　//Utiliser （ptr　+　1）->Nom et （ptr　+　1）->　age
　　　　　　　scanf("%s　%d",　(ptr+i)->name,　&(ptr+i)->age);
　　　}
　　　printf("Affichage des informations:\n");
　　　for(i = 0;　i < n;　++i)
　　　　　　　printf("Nom:　%s	Âge:　%d\n",　(ptr+i)->name,　(ptr+i)->age);
　　　return 0;
}

Lors de l'exécution de ce programme, la sortie est la suivante :

Nombre d'entrées:　　2
Saisir respectivement le nom et l'âge:　Harry　24
Saisir respectivement le nom et l'âge:　Gary　32
Affichage des informations:
Nom:　Harry	Âge:　24
Nom:　Gary	Âge:　32

Dans l'exemple ci-dessus, n variables struct ont été créées à l'endroit où l'utilisateur saisit n.

Pour allouer de la mémoire pour n struct person, nous utilisons,

ptr = (struct person*) malloc(n　*　sizeof(struct person));

Ensuite, nous utilisons le pointeur ptr pour accéder aux éléments de person.