Vous êtes sur la page 1sur 8

Programmation avancée en C 14/03/2022

Pr. A. KADDARI

Année scolaire 2021/2022

(3ème partie)

1
Programmation avancée en C 14/03/2022

II. Allocation dynamique et application sur les


tableaux
II.1 Tableaux unidimensionnels
II.2 Tableaux multidimensionnels

III. Allocation dynamique et application sur les


structures
III.1 Champs dynamiques dans une structure
III.2 Structures allouées dynamiquement

1. Champ dynamique d’une structure : dans ce


cas là, au moins un des champs de structure se
déclare sous forme d’un pointeur qui devra être
alloué avant utilisation; Alors que la variable
structurée est une variable normale.
2. Variable structurée dynamique : les champs de
structure sont normales (sans pointeurs);
alors que la variable déclarée est un pointeur
à allouer.
3. Allocation mixte : champs de structure ainsi
que la variable structurée, les deux, à allouer
dynamiquement.
4

2
Programmation avancée en C 14/03/2022

 Un champ dynamique d’une structure est un


champ déclaré sous forme d’un pointeur sur
un type, et à allouer dynamiquement avant
utilisation.
 Pour bien comprendre notre situation, on
reprend le type de structure de nombre
complexe déjà vu dans le chapitre précédent :
typedef struct {
float reel;
float imag;
} complexe;
5

 Nous allons construire un autre type de


structure nommé listComplexes représentant
un ensemble de complexes qui connait sa
taille.
 Notre tableau de complexes sera déclaré
comme pointeur dynamique.
typedef struct {
//pointeur sur tableau de complexes
complexe * tab ;
int taille ; // nombre d’éléments du tableau
} listeComplexes;
6

3
Programmation avancée en C 14/03/2022

 Dans cet exemple, les cases sont allouées


dynamiquement via le champ tab de la manière
suivante :
1- Déclaration [avec initialisation] d’une variable structurée
normale (pas nécessairement un pointeur):
listeComplexes l={NULL,longueur};

2-Allocation dynamique du champ :


l.tab=(complexe*) malloc(longueur * sizeof(*(l.tab)));

3- Teste de réussite d’allocation :


if(l.tab==NULL) ------exit(1);// traitements …

4- Libération de mémoire avant de quitter le programme :


free(t.tab);
7

1. Réaliser un programme main qui lit la taille


d’une liste des complexes au clavier,
2. puis il déclare et initialise une variable de
type listeComplexes défini ci-dessus,
3. Ensuite il alloue le tableau des complexes et
met tous ses valeurs à 0,
4. et en fin il affiche la liste à l’écran.

4
Programmation avancée en C 14/03/2022

#include <stdio.h>
#include <stdlib.h>
typedef struct {
float r, i;
} complexe;

typedef struct {
//pointeur sur tableau de complexes
complexe *tab;
int taille ; // nombre d’éléments du tableau
} listeComplexes;

int main() {
int longueur,i;
printf("La longueur de tableau :");
scanf("%d",&longueur);
//déclaration et initialisation
listeComplexes t={NULL,longueur};
//allocation dynamique et initialisation
t.tab=(complexe*) malloc (longueur * sizeof(complexe));
if(t.tab==NULL) exit (EXIT_FAILURE) // erreur d’allocation
for(i=0;i<longueur;i++) {
t.tab[i].r=0;
t.tab[i].i=0;
}//pour éviter cette boucle d’initialisation on peut utiliser calloc à l’allocation.
//affichage et libération de la mémoire
for(i=0;i<longueur;i++) {
printf("t[%d]=%.2f + %.2f i\n",i,t.tab[i].r,t.tab[i].i);
}
free(t.tab);
t.tab=NULL;
return 0;
}
10

5
Programmation avancée en C 14/03/2022

II. Allocation dynamique et application sur les


tableaux :
II.1 Tableaux unidimensionnels,
II.2 Tableaux multidimensionnels.

III. Allocation dynamique et application sur les


structures :
III.1 Champs dynamiques dans une structure,
III.2 Structures allouées dynamiquement.

11

 Dans cette partie on va travailler sur une


structure qui enregistre les informations d’un
étudiant (nom, taille et âge) déclarées comme
variables normales (les champs ne sont pas
nécessairement des pointeurs).
typedef struct {
char nom[20];
float taille ;
short int age ;
} etudiant;

12

6
Programmation avancée en C 14/03/2022

Donc, il est possible d’allouer


dynamiquement un emplacement pour un
seul étudiant via les étapes suivantes :
1- Déclaration d’un pointeur pour la variable
de structure :
etudiant * pUnEtudiant =NULL;
2- Allocation dynamique :
pUnEtudiant = (etudiant*) malloc( sizeof(etudiant) );

Remarque : on pourra faire les 2 instructions


en une seul (déclaration+allocation).

13

On peut aussi, allouer dynamiquement une liste


d’étudiants de la manière suivante :

1- Déclaration d’un pointeur de type etudiant :


etudiant * listeEtudiants=NULL;

2- Allocation d'un tableau de structures :


listeEtudiants=(etudiant*)malloc(nb_etud*sizeof(etudiant) );

Remarque : on devra savoir le nombre d’étudiants


(nb_etud) avant l’allocation.
14

7
Programmation avancée en C 14/03/2022

Réaliser un programme main qui :


1- Lit le nombre d’étudiants au clavier,
2- Lit une liste d’étudiants au clavier, et les
stockent dans un tableau de type etudiant
en nombre d’étudiants saisi,
3-Puis il l’affiche à l’écran.

15

int main() {
//affichage et libération de la mémoire
int n,i;
for(i=0;i<n;i++) {
etudiant * listeEtudiants=NULL; //

printf("Le nombre d’etudiants :"); printf("\nL’etudiant %d:",i);

scanf("%d",&n); printf("%s\t%f\t%d.",listeEtudiants[i].nom,listeEtudi

listeEtudiants=(etudiant*)malloc(n*sizeof(etudiant)); ants[i].taille,listeEtudiants[i].age);

if(listeEtudiants ==NULL) exit(1); // erreur d’allocation }


printf("\n--------------Saisie d’etudiants :---------"); free(listeEtudiants);
for(i=0;i<n;i++){ listeEtudiants=NULL;
printf("\nLe nom d’etudiant %d:",i);
return 0;
scanf("%s",listeEtudiants[i].nom);
}
printf("La taille d’etudiant %d:",i);

scanf("%f",&listeEtudiants[i].taille);

printf("L’age d’etudiant %d:",i);

scanf("%d",&listeEtudiants[i].age);

16

Vous aimerez peut-être aussi