Algorithmique et programmation 2

Chapitre 6: Structures

1
MIPC: S3
 Structures
• Définition:
Une structure est un ensemble d’éléments, pouvant être de
types différents, désigné par un seul nom. L’accès à chaque
élément (nommé champ) s’effectue par son nom au sein de la
structure.
• Déclaration: Nom de la Champs de la
structure structure

struct nom_Structure {
type1 nom_champ1;
...
typeN nom_champN;
Mot clé
struct
};

2
MIPC: S3
 Structures (suite)
• Exemple: (Déclaration d’une structure)
struct Etudiant {
char Nom[20];
char Prenom[20];
int Age;
float Moyenne;
};
• Remarques:
- Deux champs ne peuvent pas avoir le même nom.
- Un champ peut être de n’importe quel type sauf le type de
la structure dans laquelle il se trouve.

3
MIPC: S3
 Structures (suite)
• Définition d’une variable structurée:
 La déclaration d’une structure ne réserve pas d’espace
mémoire, mais elle défini le modèle (l’allure) de la
structure.
 Après avoir déclarée une structure, il faut définir les
variables structurées.
 La déclaration d’une variable structurée se fait comme
suit:
struct Nom_Structure
Nom_variable_structurée;
 On peut définir plusieurs variables structurées en les
séparant avec des virgules.
struct Nom_Structure Nom1,Nom2,Nom3,
…; 4
MIPC: S3
 Structures (suite)
• Exemple: (Variable structurée)
struct Etudiant {
char Nom[20];
char Prénom[20];
int Age;
float Moyenne;
};

struct Etudiant Etud1,Etud2,Etud3;

• On peut regrouper la déclaration et la définition dans une
seule instruction de la façon suivante:
struct nom_Structure {
type1 nom_champ1;
...
typeN nom_champN;
}Nom1,Nom2,Nom3,…;
5
MIPC: S3
 Structures (suite)
• Utilisation de « typedef »:
 Le mot-clé typedef permet d'associer un nom à un type
donné.
 On l'utilise suivi de la déclaration d'un type puis du nom
qui remplacera ce type

 Exemple:
typedef struct {
char Nom[20];
char Prénom[20];
float Moyenne;
}Etudiant;
Etudiant Etud1,Etud2,Etud3;

6
MIPC: S3
 Structures (suite)
• Accès aux champs d’une variable structurée:
 L’accès aux champs s’effectue à l’aide de l’opérateur du
champ (un point .) placé entre le nom de la variable
structurée et le nom du champ souhaitée.

Nom_variable_structurée Nom_cha .
mp;
Nom du champ

Nom de la variable
structurée

Opérateur du
champ

7
MIPC: S3
 Structures (suite)
• Exemple: (Accès aux champs)

struct Etudiant {
char Prenom[20];
int Age;
float Moyenne;
};

struct Etudiant Etud1;

Etud1.Prenom=″Ali″;
Etud1.Age = 23;
Etud1.Moyenne = 15.27;

8
MIPC: S3
 Exemple
struct Etudiant {
char Prenom[20];
int Age;
float Moyenne;
};

struct Etudiant Etud1;

Ecrire un programme qui permet la ecture et l’affichage des

information de l etudiant Etud1

9
 Structures (suite)
• Structures imbriquées:
 On peut imbriquer plusieurs structures.
 Exemple:
struct date{
int jour;
int mois;
int annee;
};
struct Etudiant {
char Nom[20];
char Prénom[20];
float Moyenne;
struct date naissance;

}Etud1;
 Accès aux champs de la sous-structure utilise deux fois
l’opérateur point (.) : Etud1.naissance.jour
10
MIPC: S3
 Transmission d’une structure en
argument d’une fonction
A. Transmission de la valeur d’une structure :
Aucun problème particulier ne se pose, par exemple :
main()
#include <stdio.h> {
struct enreg struct enreg x ;
{ x.a = 1; x.b = 12.5;
int a ; printf ("\navant appel fct : %d
float b ; %f",x.a,x.b);
};
void fct (struct enreg s) fct (x) ;
{ printf ("\nau retour dans main :
s.a = 0; s.b=1; %d
printf ("\ndans fct : %d %f", s.a, %f", x.a, x.b);
s.b); } }
12
Transmission d’une structure en
argument d’une fonction
B. Transmission de l’adresse d’une structure :
l’opérateur -> :
• Dans ce cas, la fonction fct reçoit l’adresse de la
structure et non plus sa valeur.
– L’appel de fct devra donc se présenter sous la forme :
fct (&x) ;
– Et l’en-tête sera de la forme :
void fct (struct enreg * ads)
 Transmission d’une structure en
argument d’une fonction
L’exemple précédent, en employant l’opérateur noté ->, est le
suivant :
main()
#include <stdio.h> {
struct enreg struct enreg x ;
{ x.a = 1; x.b = 12.5;
int a ; printf ("\navant appel fct :
float b ; %d %f",x.a,x.b);
};
fct (&x) ;
void fct (struct enreg * ads) printf ("\nau retour dans main : %d
{ ads->a = 0 ; ads->b = 1; %f", x.a, x.b); }
printf ("\ndans fct : %d %e", ads->a,
ads->b);
}
Structures (suite)

15
MIPC: S3
 Exercice 1
Soit le modèle de structure suivant :
struct s_point {
char c ;
int x, y ;
};
Ecrire une fonction qui reçoit en argument une structure de
type s_point et qui en affiche le contenu sous la forme :
point B de coordonnées 10 12
1. En transmettant en argument la valeur de la structure
concernée,
2. En transmettant en argument l'adresse de la structure
concernée.
Dans les deux cas, on écrira un petit programme d'essai de
la fonction ainsi réalisée.
 Exercice 1
1. #include <stdio.h>
struct s_point
{
char c ;
int x, y ;
};
void affiche (struct s_point p)
{
printf ("point %c de coordonnées %d %d\n", p.c, p.x, p.y) ;
}
main()
{
struct s_point s ;
s.c = 'A' ;
s.x = 10 ;
s.y = 12 ;
affiche (s) ;
}
 Exercice 1
2. #include <stdio.h>
struct s_point
{
char c ;
int x, y ;
};

void affiche (struct s_point *adp)

{
printf ("point %c de coordonnées %d %d\n", adp->c, adp->x, adp->y) ;
}

main()
{
struct s_point s ;
s.c = 'A' ;
s.x = 10 ;
s.y = 12 ;
affiche (&s) ;
}
 Exercice 2
1. Écrire un programme qui :
lit au clavier des informations dans un tableau de structures
du type point défini comme suit :
struct point {
int num ;
float x ;
float y ;
}
Le nombre d’éléments du tableau sera fixé par une instruction
#define.
affiche à l’écran l’ensemble des informations précédentes.
2. Réaliser la même chose que dans la question précédente,
mais en prévoyant, cette fois, une fonction pour la lecture
des informations et une fonction pour l’affichage.
 Structures (suite)
• Tableaux de structures:
 Il est possible de créer un tableau comportant des
éléments de type d’une structure donnée.
struct Nom_structure
 Exemple:
Nom_tableau[taille];
struct date{
int jour;
int mois;
int annee;
};
struct Etudiant {
char Nom[20];
char Prénom[20];
float Moyenne;
struct date naissance;

};
20
struct Etudiant Liste[30];
MIPC: S3
 Exercice2
On suppose qu’on a les déclarations suivantes:
typdef struct { typedef struct {
int jour; char Nom[20];
int mois; char Prénom[20];
int annee; float Moyenne;
} date; date naissance;
} Etudiant ;
Etudiant Liste[30];

Ecrire un programme c qui permet de saisir et afficher

les informations des étudiants.

21
MIPC: S3
1. Exercice 2
#include <stdio.h>
#define NPOINTS 5
main()
{
struct point {
int num ;
float x ;
float y ;
};
struct point courbe[NPOINTS] ;
int i ;
for (i=0 ; i<NPOINTS ; i++) {
printf ("numéro : ") ; scanf ("%d", &courbe[i].num) ;
printf ("x : ") ; scanf ("%f", &courbe[i].x) ;
printf ("y : ") ; scanf ("%f", &courbe[i].y) ;
}
printf (" **** structure fournie ****\n") ;
for (i=0 ; i<NPOINTS ; i++)
printf ("numéro : %d x : %f y : %f\n", courbe[i].num, courbe[i].x,
courbe[i].y) ;
}
 Exercice 2
void lit (struct point courbe [])
2. /* ou void lit (struct point * courbe) */
#include <stdio.h> {
#define NPOINTS 5 int i ;
struct point { for (i=0 ; i<NPOINTS ; i++)
int num ; {
float x ; printf ("numéro : ") ;
float y ; scanf("%d",&courbe[i].num);
}; printf ("x : ") ; scanf ("%f", &courbe[i].x) ;
printf ("y : ") ; scanf ("%f", &courbe[i].y) ;
}
main() }
{ void affiche (struct point courbe [])
struct point courbe[NPOINTS] ; /* ou void affiche (struct point * courbe) */
lit (courbe) ; {
affiche (courbe) ; int i ;
} printf (" **** structure fournie ****\n") ;
for (i=0 ; i<NPOINTS ; i++)
printf ("%d %f %f\n", courbe[i].num,
courbe[i].x, courbe[i].y);
}
 Exercice3

Ecrire un programme C qui permet de

calculer la somme et le produit de deux
complexes c1 et c2

24
MIPC: S3