UNIVERSITÉ CHOUAIB DOUKKALI
FACULTÉ DES SCIENCES
El Jadida
PROGRAMMATION C 2
Pr. I. EL GUABASSI
[email protected]
Tronc Commun National
Informatique Appliquée
FS - EL JADIDA 2023/2024
2 Plan
❑ Chapitre 1 : Rappels
❑ Chapitre 2 : Pointeurs et allocation dynamique de la mémoire
❑ Chapitre 3 : Les structures
❑ Chapitre 4 : Récursivité
❑ Chapitre 5 : Evaluation de la complexité de l’algorithme
❑ Chapitre 6 : Tri et recherche
❑ Chapitre 7 : Les fichiers
CHAPITRE 3
❑ Les structures
o Introduction
o Déclaration
o Initialisation
o Accès aux champs d’une structure
o Structure comportant des tableaux
o Structure comportant d’autres structures
o Tableaux de structures
o Utilisation de typedef
o Pointeurs de structure
o Structures et fonctions
4 Les structures
Introduction
Un tableau permet de regrouper sous un seul nom un
ensemble de valeurs de même type, repérées par des indices.
Cependant, comment puis-je désigner sous un seul nom un
ensemble de valeurs pouvant être de types différents?
Problème
En langage C, vous pouvez utiliser une structure. En fait, une
structure est un moyen de regrouper différentes variables
sous un même nom, chaque variable pouvant être de type
Solution différent
5 Les structures
Introduction
Chaque avion est caractérisé par
Un type
Un modèle
Un nombre de passagers
Etc.
Les mêmes caractéristiques pour chaque avion.
6 Les structures
Introduction
Un type
Un avion est caractérisé par Un modèle
Un nombre de passagers
Etc.
Un CNE
Un Nom
Un étudiant est caractérisé par Un Prénom
Etc.
Une matricule
Un modèle
Une voiture est caractérisée par Une marque
Etc.
7 Les structures
Introduction
char type[20] char CNE[20] char matricule[20]
char modele[20] char nom[20] char modele[20]
char prenom[20] char marque[20]
int nbrPassagers
Structure Avion Structure Etudiant Structure Voiture
8 Les structures
Introduction
• Une structure est un nouveau type de données constitué par un ensemble
de variables (champs) qui peuvent être hétérogènes et de types différents
• La différence avec le type tableau est que les champs d’un tableau sont
tous homogènes et du même type
• Les structures permettent de représenter des objets réels caractérisées par
plusieurs informations, par exemple :
o Une personne caractérisée par son nom (chaîne), son âge (entier), sa
taille (réel), etc.
o Une voiture caractérisée par sa marque (chaîne), sa couleur (chaîne),
son année modèle(entier), etc.
9 Les structures
Introduction
Définir une variable de type structure suppose avoir d'abord défini le modèle
de cette structure en décrivant l'ensemble des champs contenus et en lui
associant un nom. Un modèle de structure constitue en fait un nouveau type
de variable défini par l'utilisateur
Nom du champ
• Chaque élément de la structure est nommé champ
• L’accès à un champ se fait par son nom dans la structure
10 Les structures
Déclaration
La déclaration d'une structure s'effectue en précisant le nom de la structure,
ainsi que le nom et le type de ses champs
Syntaxe Exemple
struct NomStructure {
struct Etudiant {
type champ1; char Nom[30];
int Age;
type champ2;
float MoyenneScolaire;
type champn; };
/* Cette structure contient 3
};
champs de différents types */
/* ne pas oublier le ; */
11 Les structures
Déclaration Remarques
✓ Le nom des champs répond aux critères des noms de variables
✓ Deux champs ne peuvent avoir le même nom
✓ Les données peuvent être de n'importe quel type hormis le type de
la structure dans laquelle elles se trouvent
✓ La déclaration d'une structure ne fait que donner le modèle ou la
forme de la structure, c'est-à-dire en quelque sorte une définition
d'un type de variable complexe.
12 Les structures
Définition d’une variable de type structure
La définition d'une variable structurée est une opération qui consiste à
créer une variable ayant comme type celui d'une structure que l’on a
précédemment déclaré, Ceci peut se faire soit :
Après la déclaration de la Au moment de la déclaration de la
structure structure
struct Etudiant { struct Etudiant {
char Nom[30]; char Nom[30];
int Age; int Age;
float MoyenneScolaire; float MoyenneScolaire;
}; } E1, E2;
struct Etudiant E1, E2; /*deux variables de type struct personne*/
Syntaxe struct <Nom_Structure> <Variable>;
13 Les structures
Définition d’une variable de type structure
En mémoire, en déclarant les variables E1, et E2, l’espace réservé aura
l'aspect suivant :
Nom Age MoyenneScolaire
E1
Nom Age MoyenneScolaire
E2
14 Les structures
Initialisation
Lors de la déclaration d’une variable structure, on peut initialiser ses
champs avec une notation semblable à celle utilisée pour les tableaux en
indiquant la liste des valeurs respectives entre accolades {}. Chaque
valeur étant une constante ayant le type du champ correspondant.
Exemples
struct Etudiant { struct date {
int niveau; unsigned short jour;
float moyenne; char mois[10];
}; unsigned short annee;
struct Etudiant E1 = {2, 10.9}; };
struct Etudiant E2 = {2, 12.5}; struct date d1= {15,"Novembre", 2013};
15 Les structures
Accès aux champs d’une structure
Chaque variable de type structure possède des champs repérés avec des
noms uniques. Toutefois le nom des champs ne suffit pas pour y accéder
étant donné qu'ils n'ont de contexte qu'au sein de la variable structurée.
Il est possible d'utiliser une structure de deux manières :
✓ en travaillant individuellement sur chacun de ses champs
✓ en travaillant de manière "globale" sur l'ensemble de la structure.
16 Les structures
Accès aux champs d’une structure Utilisation des champs d'une structure
Chaque champ d'une structure peut être manipulé comme n'importe quelle
variable du type correspondant. La désignation d'un champ se note en
faisant suivre le nom de la variable structure de l'opérateur "point" (.) suivi
du nom de champ tel qu'il a été défini dans le modèle.
Exemple
struct personne p1 ;
p1.age= 20 ;
printf ("%d", p1.age) ;
scanf ("%s",p1.nom) ;
puts(p1.nom) ;
17 Les structures
Accès aux champs d’une structure Utilisation globale d'une structure
Le langage C permet d'effectuer des affectations de structures, en utilisant
l'opérateur d'affectation =, comme pour n'importe quel autre type de données.
Notez que celui-ci affecte l'ensemble des champs de la structure ; si vous ne
souhaitez copier que quelques uns de ses champs, il vous faudra les copier un
par un. De plus, il n'est possible d'affecter que des structures de même type !
Exemple
strcpy(fils1.nom,fils2.nom);
fils1 = fils2 ; strcpy(fils1.prenom,fils2.prenom);
fils1.age= fils2.age;
18 Les structures
19 Les structures
Exercice
Ecrire un programme C qui définit une structure point qui contiendra
les deux coordonnées d’un point du plan. Puis lit deux points et affiche
la distance entre ces deux derniers.
AB=√(x2−x1)2 +(y2−y1)
2
20 Les structures
#include<stdio.h>
Solution
#include<math.h>
struct point{
float x;
float y;
};
int main() {
struct point A,B;
float dist;
printf("Entrez les coordonnees du point A:\n");
scanf("%f%f",&A.x,&A.y);
printf("Entrez les coordonnees du point B:\n");
scanf("%f%f",&B.x,&B.y);
dist = sqrt( (B.x-A.x)*(B.x-A.x) + (B.y-A.y)*(B.y-A.y) );
printf("La distance entre les points A et B est: %.2f\n",dist);
return 0;
}
21 Les structures
Structure comportant des tableaux
Une structure peut contenir des champs de type chaîne de caractères
ou bien de type tableau
Exemple
struct UnEtudiant {
char nom [30];
char prenom [30];
float notes [4];
int niveau;
float moyenne;
};
struct UnEtudiant Etudiant1, Etudiant2;
22 Les structures
Structure comportant des tableaux
Notation
Etudiant1.nom[0] /*le premier caractère du champ nom de l’étudiant Etudiant1*/
Etudiant2.notes[3] /*la quatrième note du tableau notes de l’étudiant Etudiant2*/
notes niveau
Initialisation nom prenom moyenne
struct UnEtudiant Etudiant1 = {"Ben Salem", "Ali",{10.0,12.5,13.6, 7.5},2,10.9};
struct UnEtudiant Etudiant2 = {"Selmi ", "Ahmed",{12.0,12.5,14.0, 11.5},2,12.5};
Utilisation
strcpy (Etudiant1.nom, "Ben Salem");
Etudiant1.notes[2] = 13.6;
printf ("%f", Etudiant2.notes[i]);
23 Les structures
Structure comportant d’autres structures
Une structure peut contenir aussi des champs de type structure. Cette
dernière doit être différente de la première.
struct Date {
int jour;
int mois;
int annee;
};
struct UnEtudiant {
char nom [30] ;
char prenom [30] ;
struct Date dateNais ;
};
24 Les structures
Structure comportant d’autres structures
Initialisation année
jour
struct UnEtudiant Etudiant1 = {"Ali", "Ben Salem", {1, 1, 2000}};
mois
Utilisation
Etudiant1.date.jour = 1;
scanf("%d %d %d",&Etudiant1.dateNais.jour, &Etudiant1.dateNais.mois,
&Etudiant1.dateNais.annee);
25 Les structures
Tableaux de structures
Étant donné qu'une structure est composée d'éléments de taille fixes, il est
possible de créer un tableau ne contenant que des éléments du type d'une
structure donnée. Il suffit de créer un tableau dont le type est celui de la
structure et de le repérer par un nom de variable:
Etudiant [4] :
Etudiant [0] Etudiant [1] Etudiant [2] Etudiant [3]
Assal Zidani ZAHNOUNE Tahiri
Sanae Oumaima Fadoua Yassine
18 20 22 18
26 Les structures
Tableaux de structures
Déclaration
struct <Nom_Structure> {
<type_champ1> <Nom_Champ1>; Accès
…
<type_champN> <Nom_ChampN>; A un élément du tableau :
};
<Tab_Struct>[i] (structure N° i)
struct <Nom_Structure> <Tab_Struct>[N];
A un élément d’une structure :
<TabStruct>[i].<NomChampj>
Exemple
27 Les structures
Tableaux de structures Exemple
Soit la déclaration suivante : On peut écrire les instructions suivantes :
struct Etudiant { for (i = 0; i < 50; i++) {
printf ("Entrez le nom de l ’étudiant n°%d ", i+1);
char nom [30] ; scanf ("%s", tab[i].nom);
char prenom [30] ; printf ("Entrez le prénom de l’étudiant n°%d ", i+1);
scanf ("%s", tab[i].prenom);
float notes [4] ; for (j =0; j < 4; j++) {
}; printf ("Entrez la note %d de l’étudiant %d ", j+1, i+1);
scanf ("%f", &tab[i].notes[j]);
struct Etudiant tab [50]; }
}
28 Les structures
Utilisation de typedef
Comment puis-je éviter d’utiliser le mot-clé struct à chaque
utilisation d'une variable de type Etudiant ?
struct Etudiant {
int niveau;
float moyenne;
Problème
};
struct Etudiant E1 = {2, 10.9};
struct Etudiant E2 = {2, 12.5};
struct Etudiant E2 = {2, 11.5};
Pour éviter d'utiliser le mot-clé struct à chaque utilisation
d'une variable de type Etudiant, vous pouvez utiliser la
Solution directive typedef.
29 Les structures
Utilisation de typedef
Le mot-clé typedef permet d'associer un nom à un type donné. La principale
utilité des typedef est de faciliter l'écriture des programmes. Lorsqu'on donne
un nom à un type structure par typedef, l'utilisation est beaucoup plus aisée.
Exemple
typedef struct {
char nom[32] ;
char prenom[32] ;
int age ;
} personne ;
personne p1 ;
p1.age= 20 ;
printf ("%d", p1.age) ;
scanf ("%s",p1.nom) ;
puts(p1.nom) ;
30 Les structures
Pointeurs de structure
Il est aussi possible d'accéder aux champs d'une structure en utilisant
un pointeur sur cette structure :
✓ Si p est un pointeur sur une structure, on peut accéder à un
membre de la structure pointé par l’expression: (*p).membre
✓ Cette notation peut être simplifiée grâce à l’opérateur pointeur de
membre de structure, noté -> (tiret et supérieur) : p->membre
Exemple
31 Les structures
Pointeurs de structure Exemple
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int day;
int month;
int year;
} Date;
int main() {
Date *Date_ptr=(Date*)malloc(sizeof(Date));
Date_ptr->month = 9;
Date_ptr->day = 25;
Date_ptr->year = 1983;
printf("Today is %d/%d/%d",Date_ptr->month,Date_ptr->day,Date_ptr->year % 100);
free(Date_ptr);
return 0; }
32 Les structures
Structures et Fonctions Transmission de la valeur d'une structure
struct personne {
Une structure peut être utilisée
char nom[20];
char prenom[20];
comme argument d’une fonction int age;
et transmise par valeur };
void Afficher_personne( struct personne p) {
printf(" le nom est : %s\n" ,p.nom);
printf(" le prénom est : %s\n" ,p.prenom);
printf(" \’age est : %d\n" ,p.age);
}
main() {
struct personne p1={"Mrabit", "Hicham", 30};
Afficher_personne(p1);
}
33 Les structures
Structures et Fonctions Transmission de l'adresse d'une structure
Pour changer les valeurs de la structure, on envoie un pointeur
struct personne {
char nom[20];
char prenom[20];
int age;
}; main() {
void changer_personne( struct personne *p) { struct personne p1={"Hatri","Ali",30};
strcpy((*p).nom,"Alaoui"); Afficher_personne(p1);
strcpy((*p).prenom,"Hassan"); changer_personne(&p1);
(*p).age=20; Afficher_personne(p1);
} }
void Afficher_personne( struct personne p) {
printf(" le nom est : %s\n" ,p.nom);
printf(" le prénom est : %s\n" ,p.prenom);
printf(" \’age est : %d\n" ,p.age); }
34 Les structures
Structures et Fonctions Structure en valeur de retour
Le langage C autorise à réaliser des fonctions qui fournissent en retour la valeur
d'une structure main() {
struct personne { struct personne p1={"Harti", "Ali", 30};
char nom[20]; Afficher_personne(p1);
char prenom[20]; p1=changer_personne(p1);
int age; }; Afficher_personne(p1); }
struct personne changer_personne( struct personne p) {
strcpy(p.nom,"Alaoui");
strcpy(p.prenom,"Hassan");
p.age=20;
return p; }
void Afficher_personne( struct personne p) {
printf(" le nom est : %s\n" ,p.nom);
printf(" le prénom est : %s\n" ,p.prenom);
printf(" \’age est : %d\n" ,p.age); }
35 Les structures
36 Les structures
Exercice
Ecrire un programme C qui définit une structure Etudiant où un
étudiant est représenté par son nom, son prénom et une note. Lit
ensuite une liste d’étudiants entrée par l’utilisateur et affiche les
noms de tous les étudiants ayant une note supérieure ou égale
à 10 sur 20.
37 Les structures
Solution int main() {
struct Etudiant t[100];
int n,i;
printf("Donner le nombre d'etudiants:\n");
scanf("%d",&n);
#include<stdio.h> for(i=0;i<n;i++) {
struct Etudiant{ printf("donnez le nom, prenom et la note de
char nom[20]; l'etudiant %d:\n",i+1);
char prenom[20]; scanf("%s%s%d",t[i].nom,t[i].prenom,&t[i].note);
int note; }
}; for(i=0;i<n;i++) {
if(t[i].note>=10)
printf("%s %s\n",t[i].nom,t[i].prenom);
}
return 0;
}
