Structures in C Programming
Structures en programmation C Les structures en programmation C sont des types de données qui permettent de regrouper des éléments de types différents sous un même nom. Contrairement aux tableaux, qui ne contiennent que des éléments d'un même type, les structures peuvent contenir des membres de types variés.
D'après le document Structures in C Programming
Cet article a été rédigé automatiquement à partir du document source, puis vérifié avant publication.
Document source
Computer Science - Programming in C · PDF · 12 pages · 2011
Afficher l'aperçu du document
Structures en programmation C
Les structures en programmation C sont des types de données qui permettent de regrouper des éléments de types différents sous un même nom. Contrairement aux tableaux, qui ne contiennent que des éléments d'un même type, les structures peuvent contenir des membres de types variés. Cela les rend particulièrement utiles pour représenter des objets complexes, comme une personne ou une planète, en regroupant des informations pertinentes.
Notion d'enregistrement ou de structure
Dans le langage C, ce que l'on appelle communément un enregistrement est désigné par le terme "structure". Chaque élément d'une structure est appelé "membre". Avant de déclarer une variable de type structure, il est nécessaire de définir son type, c'est-à-dire le nom et le type des membres qui la composent. Le type d'une structure est appelé type structuré.
Syntaxe de déclaration d'une structure
Pour déclarer une structure, plusieurs méthodes existent. Par exemple, pour créer une structure représentant une personne avec un nom, un prénom et un numéro d'employé, on peut procéder comme suit :
struct personne {
char nom[20];
char prenom[20];
int no_employe;
};
Cette déclaration crée un type de structure nommé "personne". On peut ensuite déclarer des variables de ce type :
struct personne p1, p2;
Autres méthodes de déclaration
Il est également possible de déclarer des variables de type structure sans utiliser d'étiquette de structure :
struct {
char nom[20];
char prenom[20];
int no_employe;
} p1, p2;
Cependant, cette méthode ne permet pas de réutiliser le type de structure pour d'autres variables. Une autre méthode consiste à combiner la déclaration d'étiquette de structure et la déclaration de variables :
struct personne {
char nom[20];
char prenom[20];
int no_employe;
} p1, p2;Enfin, on peut utiliser typedef pour simplifier la déclaration :
typedef struct {
char nom[20];
char prenom[20];
int no_employe;
} PERSONNE;
Les déclarations de variables se feront alors par :
PERSONNE p1, p2;
Initialisation d'une structure
Une structure peut être initialisée en utilisant une liste d'expressions constantes. Par exemple :
struct personne p = {"Jean", "Dupond", 7845};
Pour une structure représentant une planète, on peut définir le type structuré comme suit :
struct planete {
char nom[20];
float densite;
float distance;
int nbSatellites;
};
Pour initialiser plusieurs planètes, on peut procéder ainsi :
struct planete p1 = {"Mercure", 5.42, 58, 0};
struct planete p2 = {"Venus", 5.25, 108.2, 0};
struct planete p3 = {"Terre", 5.52, 149.6, 1};
Opérateurs sur les structures
Accès aux membres de la structure
Pour accéder à un membre d'une structure, on utilise l'opérateur de sélection de membre, noté .. Par exemple, pour accéder au nom de la personne représentée par p1, on écrira p1.nom.
Affectation de structures
Il est possible d'affecter une structure à une autre variable de même type :
struct personne p1, p2;
p1 = p2;
Comparaison de structures
Aucune comparaison directe n'est possible sur les structures, même pas avec les opérateurs == et !=.
Passage de structure en paramètre
Lorsqu'une structure est passée en paramètre à une fonction, il est nécessaire de définir la structure au préalable. Par exemple, pour comparer deux dates :
struct date {
int jour, mois, annee;
};
enum {AVANT, EGAL, APRES};
int cmp_date(struct date d1, struct date d2) {
if (d1.annee > d2.annee) return(APRES);
if (d1.annee < d2.annee) return(AVANT);
// Comparaison sur mois et jour
}
Tableaux de structures
Pour déclarer un tableau de structures, on utilise la même syntaxe que pour un tableau d'éléments simples :
struct personne t[100];
Pour accéder au nom de la personne à l'index i, on écrira t[i].nom.
Questions fréquentes
Comment déclarer une structure en C ?
Pour déclarer une structure en C, utilisez le mot-clé struct suivi du nom de la structure et des membres entre accolades. Par exemple :
struct personne {
char nom[20];
char prenom[20];
int no_employe;
};
Comment initialiser une structure en C ?
Une structure peut être initialisée lors de sa déclaration en utilisant une liste d'initialisation. Par exemple :
struct personne p = {"Jean", "Dupond", 7845};
Quels opérateurs peut-on utiliser avec les structures ?
On peut utiliser l'opérateur . pour accéder aux membres d'une structure, et l'opérateur = pour affecter une structure à une autre de même type. Toutefois, la comparaison directe des structures n'est pas possible.
Peut-on passer une structure en paramètre à une fonction ?
Oui, une structure peut être passée en paramètre à une fonction. Il suffit de déclarer la structure au préalable et de l'utiliser comme type de paramètre dans la fonction.
Comment déclarer un tableau de structures en C ?
Pour déclarer un tableau de structures, utilisez la syntaxe suivante :
struct personne t[100];
Vous pouvez ensuite accéder aux membres des structures dans le tableau en utilisant l'opérateur ..
Commentaires
Aucun commentaire pour le moment. Posez la première question.