22/10/2019

Les types structurés

(les enregistrements)

Type structuré
• Un type structuré(ou enregistrement) est une structure de données permettant
de sauvegarder des éléments hétérogènes (de type différent).
Traduction en langage C:
Types struct etudiant
{int num_inscr;
Structure etudiant
char nom[20];
num_inscr: entier float moyenne;};
nom : chaîne
Moyenne : réel Main()
Fin structure {struct etudiant E1,E2;
struct etudiant TE[20];
Var …
E1,E2 : etudiant scanf("%d",&TE[0].num_inscr);
TE : tableau[1..20] : etudiant }

1
 22/10/2019

Traduction en langage C:
struct etudiant
Type structuré {int num_inscr;
char nom[20];
• Saisie d’une variable structure float moyenne;};

Main()
lire(E1.num_inscr) {struct etudiant E1,E2;
lire(E1.nom, E1,moyenne) struct etudiant TE[20];
…
scanf("%d", &E1,num_inscr);
Pour i de 1 à 20 faire scanf("%s%f", E1.nom, &E1.moyenne);
lire(TE[i].num_inscr, TE[i].nom,
for(i=0;i<20;i++)
TE[i].moyenne) {scanf("%d",&TE[i].num_inscr);
Fin pour ….}

Structures de structures
• Une structure peut contenir des éléments de type simple ou des éléments de
type composé.
Traduction en langage C:
Types struct adresse
{int num;
Structure adresse char rue[30];};
num : entier typedef struct adresse home;
struct etudiant
rue : chaîne {int num_inscr;
Fin structure char nom[20];
float moyenne;
Structure etudiant home residence;};
num_inscr: entier
nom : chaîne Main()
{struct etudiant E1,E2;
moyenne : réel struct etudiant TE[20];
residence : adresse …
scanf("%d",&TE[i].residence.num);
Fin structure }

2
 22/10/2019

Traduction en langage C:
Structures avec tableau Typedef struct
{int num;
char rue[30];} adresse;
• Une structure peut contenir parmi ses struct etudiant
éléments un tableau. {int num_inscr;
char nom[20];
Types float moyenne;
Structure adresse adresse residence[3];};
num : entier
Main()
rue : chaîne
{struct etudiant E1,E2;
Fin structure struct etudiant TE[20];
Structure etudiant …
num_inscr: entier scanf("%d",&TE[i].residence[0].num);
nom : chaîne scanf("%d",&TE[i].residence[0].rue);
moyenne : réel scanf("%d",&TE[i].residence[1].num);
residence : tableau [1..3] : adresse ….
}
Fin structure

3
 Série n°5
Algorithmique et programmation

Exercice 1
On se propose de gérer une classe de N étudiants (0<N≤20). Un étudiant est caractérisé par
son numéro d’inscription, son nom et sa moyenne.

Ecrire un programme C permettant de :

1. Définir une structure étudiant comportant un numéro d’inscription, un nom et une
moyenne,
2. Saisir un tableau de N étudiants,
3. De trier le tableau des étudiants selon un ordre décroissant des moyennes
4. Et d’afficher le tableau résultat.

Exercice 2
On se propose de gérer les commandes d’une entreprise par un tableau (taille ≤ 50).
Une commande est composée : d’un nom de produit, d’une quantité, d’un prix unitaire et du
client qui a passé la commande.
Un client est caractérisé par : un nom, un numéro de téléphone et un email.

1- Définir les structures client et commande.

2- Ecrire une fonction qui permet de saisir un client.
3- Ecrire une procédure qui permet de saisir une commande.
4- Ecrire une fonction qui permet de rechercher le numéro de téléphone du client qui a passé
la commande la plus généreuse dans un tableau de commandes (la commande ayant le
plus grand montant=quantité*prix unitaire).
5- Ecrire une fonction récursive qui permet de retourner le nombre de commandes d’un
même client. Cette fonction recevra en entrée un tableau de commandes, la taille du
tableau et le numéro de téléphone du client pour lequel on calculera le nombre de
commandes.
6- Ecrire l’algorithme principal qui permet :
a. de saisir la taille du tableau de commandes,
b. de saisir les commandes,
c. d’afficher les données du client qui a passé la commande la plus généreuse,
d. d’afficher les données du client le plus fidèle (ayant passé le plus de commandes).
 Série 5 Exercice 1
struct etudiant
{
int num_insc;
char nom[20];
float moyenne;
};
typedef struct etudiant etud;

etud saisir_e()
{
struct etudiant x;
printf("Saisir les donnees d'un etudiant\n");
printf("num :");scanf("%d",&x.num_insc);
printf("nom :");scanf("%s",x.nom);
printf("moyenne :");scanf("%f",&x.moyenne);
return x;
}

void saisir_e2(etud *e)

{
struct etudiant x;
printf("Saisir les donnees d'un etudiant\n");
printf("num :");scanf("%d",&x.num_insc);
printf("nom :");scanf("%s",x.nom);
printf("moyenne :");scanf("%f",&x.moyenne);
*e=x;
}

void afficher_e(etud e)
{
printf("num inscr : %d\n",e.num_insc);
printf("nom : %s\n",e.nom);
printf("moyenne : %f\n",e.moyenne);
}

int main()
{
etud TE[20];
int i, permut, n;
etud aux;
do{
printf("Saisir n :");
scanf("%d",&n);
}while(n<1 || n>20);

for(i=0;i<n;i++)
TE[i]=saisir_e();//saisir_e2(&TE[i]);

do{
permut=0;
for(i=0;i<n-1;i++)
{
if(TE[i].moyenne <TE[i+1].moyenne)
{
aux=TE[i];
TE[i]=TE[i+1];
TE[i+1]=aux;
permut=1;
}
}

}while(permut);

for(i=0;i<n;i++)
afficher_e(TE[i]);
}
 Série 5 Exercice2
#include <stdio.h>
typedef struct
{
char nom[20];
int tel;
char mail[20];
}client;

typedef struct
{
char nomp[20];
int qte;
float pu;
client clt;
}cmd;

client saisirclt()
{ client x;
printf("\n nom client :");scanf("%s",x.nom);
printf("\n tel client :");scanf("%d",&x.tel);
printf("\n mail client :");scanf("%s",x.mail);
return x;
}
void saisircmd(cmd *commande)
{
cmd c;
printf("\n ******* Saisir commande :");
printf("\n nom produit :");scanf("%s",c.nomp);
printf("\n quantite produit :");scanf("%d",&c.qte);
printf("\n prix unit :");scanf("%f",&c.pu);
c.clt=saisirclt();
*commande = c;
}

int rechercher_gen(cmd T[50],int n)

{
int i,imax=0;
for(i=1;i<n;i++)
{
if (T[i].qte*T[i].pu > T[imax].qte*T[imax].pu)
imax=i;
}
return T[imax].clt.tel;
}

int nb_commandes(cmd T[50],int n, int t)

{
if (n==0)
return 0;
else
if (T[n-1].clt.tel==t)
return 1+ nb_commandes(T,n-1,t);
else
return nb_commandes(T,n-1,t);

void Afficher_tel (cmd T[50], int n, int t)

{
int i=0;
while(T[i].clt.tel != t && i<n-1)
i++;

if (T[i].clt.tel == t)
printf("\n nom : %s , telephone : %d , mail : %s",T[i].clt.nom, t, T[i].clt.mail);
}
void main()
{
cmd tab[50];
int n,i,im;

do
{
printf("Saisir nombre commandes");
scanf("%d",&n);
}while(n<1 || n>50);

for(i=0;i<n;i++)
saisircmd(&tab[i]);

printf("\n ******* Les commandes saisies : ");

for(i=0;i<n;i++)
{
printf("\n\n commande %d : %s , %d , %f - ",i, tab[i].nomp,tab[i].qte,tab[i].pu );
printf("client : %s , %d", tab[i].clt.nom,tab[i].clt.tel);
}

printf("\n ******* Le client ayant la commande la plus généreuse : ");

Afficher_tel(tab,n,rechercher_gen(tab,n));

printf("\n ******* Le client le plus fidèle (le plus de commandes) : ");

im=0;
for(i=1;i<n;i++)
{
if (nb_commandes(tab,n,tab[i].clt.tel)>nb_commandes(tab,n,tab[im].clt.tel))
im=i;
}
Afficher_tel(tab,n,tab[im].clt.tel);
}