Programmation Structurée 2- L1 GE

Chapitre 1 : Les structures

1. Introduction

En C, les structures sont un moyen de regrouper plusieurs variables sous un même nom.
Chaque variable à l'intérieur d'une structure est appelée un membre de la structure, et ces
membres peuvent être de types différents.

2. Définition et syntaxe d'une structure

La définition d'une structure en C suit cette syntaxe générale :

struct NomStructure {

type1 membre1;

type2 membre2;

...

typeN membreN;

};

 struct : mot-clé qui indique que vous définissez une structure.

 NomStructure : nom de la structure (doit être unique).
 membre1, membre2, ... : variables membres de la structure. Elles peuvent être de
types différents (entiers, flottants, tableaux, etc.).

Exemple basique :

struct Person {

char name[50]; // Membre 1 : chaîne de caractères

int age; // Membre 2 : entier

Mme. Imen AZZOUZ 1

Programmation Structurée 2- L1 GE

float height; // Membre 3 : flottant

};

3. Utilisation d'une structure

 Déclaration d'une variable de structure :

Après avoir défini la structure, vous pouvez déclarer des variables de cette structure :

struct Person person1; // Déclaration d'une variable person1 de type struct Person

 Accès aux membres :

Utilisez l'opérateur . (point) pour accéder aux membres de la structure.

[Link] = 25; // Affectation de valeur à un membre

strcpy([Link], "Alice"); // Pour affecter une chaîne de caractères
[Link] = 1.75;

 Initialisation directe :

Vous pouvez également initialiser les membres lors de la déclaration de la variable :

struct Person person2 = {"Bob", 30, 1.80};

#include <stdio.h>

#include <string.h>

struct Person {

char name[50];

int age;

float height;

};

Exemple complet :

int main() {

Mme. Imen AZZOUZ 2

Programmation Structurée 2- L1 GE

// Déclaration d'une variable de structure

struct Person person1;

// Affectation de valeurs aux membres

strcpy([Link], "Alice");

[Link] = 25;

[Link] = 1.75;

// Affichage des valeurs

printf("Nom: %s\n", [Link]);

printf("Âge: %d\n", [Link]);

printf("Taille: %.2f\n", [Link]);

return 0;

4. Structures imbriquées

Les structures peuvent contenir d'autres structures comme membres. Cela est utile lorsque
vous devez représenter des données hiérarchiques.

Exemple :

#include <stdio.h>

struct Address {

char street[50];

int number;

} address;

Struct Person {

Mme. Imen AZZOUZ 3

Programmation Structurée 2- L1 GE

char name[50];

int age;

Address address;

} person1;

int main() {

Person person1 = {"David", 45, {"Elm Street", 12}};

printf("Nom: %s\n", [Link]);

printf("Âge: %d\n", [Link]);

printf("Adresse: %s, numéro %d\n", [Link], [Link]);

return 0;

5. Structures avec des tableaux et des chaînes de caractères

Il est courant d'utiliser des tableaux à l'intérieur des structures, notamment pour stocker des
listes d'éléments ou des chaînes de caractères.

5.1. Structure avec tableau de structures

Une structure peut contenir un tableau de structures pour gérer des collections d'objets
similaires.

Exemple :

#include <stdio.h>

Struct Person {

Mme. Imen AZZOUZ 4

Programmation Structurée 2- L1 GE

char name[50];

int age;

};

int main() {

// Tableau de personnes

Person people[3] = {

{"John", 28},

{"Lucy", 32},

{"Mark", 40}

};

for (int i = 0; i < 3; i++) {

printf("Personne %d: %s, Âge: %d\n", i + 1, people[i].name, people[i].age);

return 0;

6. Exemple de tableau de structures avec une structure embarquée

Un tableau de structures avec des structures imbriquées (ou embarquées) permet de gérer
des données complexes en regroupant plusieurs types d'informations sous une seule entité.
 Exemple de tableau de structures avec une structure embarquée
Imaginons que vous vouliez créer un tableau de personnes où chaque personne a un nom, un
âge et une adresse (qui elle-même contient une rue et un numéro de maison). Ici, l'adresse est
une structure embarquée dans la structure Person.

Mme. Imen AZZOUZ 5

Programmation Structurée 2- L1 GE

Exemple :
#include <stdio.h>

// Structure pour l'adresse

struct Address {
char street[50];
int number;
};

// Structure pour la personne, contenant une structure Address

struct Person {
char name[50];
int age;
struct Address address; // Structure embarquée
};

int main() {
// Déclarer un tableau de 3 personnes
struct Person people[3];

// Initialiser les valeurs des personnes dans le tableau

// Personne 1
strcpy(people[0].name, "Alice");
people[0].age = 25;
strcpy(people[0].[Link], "Main Street");
people[0].[Link] = 123;

// Personne 2
strcpy(people[1].name, "Bob");
people[1].age = 30;
strcpy(people[1].[Link], "Oak Avenue");
people[1].[Link] = 456;

Mme. Imen AZZOUZ 6

Programmation Structurée 2- L1 GE

// Personne 3
strcpy(people[2].name, "Charlie");
people[2].age = 35;
strcpy(people[2].[Link], "Pine Road");
people[2].[Link] = 789;

// Afficher les informations des personnes

for (int i = 0; i < 3; i++) {
printf("Nom: %s\n", people[i].name);
printf("Âge: %d\n", people[i].age);
printf("Adresse: %s, Numéro: %d\n\n", people[i].[Link],
people[i].[Link]);
}

return 0;
}

Explication :

1. Structure Address :
o Contient une rue (street) et un numéro (number).
2. Structure Person :
o Contient un nom (name), un âge (age), et une structure Address qui est la
structure embarquée.
3. Tableau de structures :
o struct Person people[3]; : Déclare un tableau de 3 personnes.
4. Initialisation des membres :
o Chaque personne dans le tableau a un nom, un âge, et une adresse composée
d'une rue et d'un numéro de maison. L'initialisation est faite pour chaque
élément du tableau à l'aide de people[i].membre.
5. Affichage :
o Une boucle for permet de parcourir le tableau et d'afficher les informations de
chaque personne, y compris leur adresse.

Mme. Imen AZZOUZ 7

Programmation Structurée 2- L1 GE

Exemple de sortie :

Nom: Alice

Âge: 25

Adresse: Main Street, Numéro: 123

Nom: Bob

Âge: 30

Adresse: Oak Avenue, Numéro: 456

Nom: Charlie

Âge: 35

Adresse: Pine Road, Numéro: 789

Points importants :

 Les structures imbriquées permettent de mieux organiser les données, surtout

lorsqu'il y a plusieurs informations connexes à stocker.
 Un tableau de structures est utile pour gérer plusieurs entités de même type (ici, des
personnes).
 Vous accédez aux membres d'une structure embarquée avec la notation point . (par
exemple, people[i].[Link] pour accéder à la rue de l'adresse).

Mme. Imen AZZOUZ 8

Programmation Structurée 2- L1 GE

Chapitre 2 : Les fonctions

1. Introduction

Les fonctions en C permettent de diviser un programme en sous-programmes ou sous-

routines. Elles facilitent la lisibilité, la réutilisation du code et la gestion de programmes
complexes. Ce cours portera sur les fonctions sans pointeurs, en traitant les concepts
suivants :

 Définition d'une fonction

 Syntaxe d'une fonction
 Types de fonctions
 Passage de paramètres par valeur
 Exemples d'utilisation
 Récursivité
2. Définition d'une fonction

Une fonction est un bloc de code qui effectue une tâche spécifique. Il existe deux types
principaux de fonctions en C :

 Fonctions prédéfinies (comme printf(), scanf()).

 Fonctions définies par l'utilisateur, créées par les développeurs pour résoudre des
problèmes spécifiques.

3. Syntaxe d'une fonction

Une fonction en C se compose de trois parties principales :

1. Déclaration de la fonction (facultatif mais recommandé).

2. Définition de la fonction (où le code de la fonction est écrit).
3. Appel de la fonction (l'endroit où la fonction est utilisée dans le programme).

 Déclaration d'une fonction :

Avant d'utiliser une fonction dans un programme, il est conseillé de la déclarer, surtout si elle
est utilisée avant d'être définie. La déclaration indique le type de retour, le nom et les

Mme. Imen AZZOUZ 1

Programmation Structurée 2- L1 GE

paramètres de la fonction.

Syntaxe :

type_retour nom_de_fonction(type_param1 param1, type_param2

param2, ...);

 type_retour : le type de la valeur renvoyée par la fonction (par exemple int, float,
void si elle ne renvoie rien).
 nom_de_fonction : le nom de la fonction.
 type_param1, type_param2, ... : les types et noms des paramètres que la
fonction recevra (facultatif si la fonction ne prend aucun paramètre).

 Définition d'une fonction :

C'est la partie du programme où vous écrivez le code qui sera exécuté lorsque la fonction est
appelée.

Syntaxe :

type_retour nom_de_fonction(type_param1 param1, type_param2

param2, ...) {
// Corps de la fonction
return valeur; // Renvoie une valeur du type type_retour
}

 Appel d'une fonction :

Une fonction est appelée pour exécuter son code dans le programme principal.

Syntaxe :

nom_de_fonction(valeur_param1, valeur_param2, ...);

Mme. Imen AZZOUZ 2

Programmation Structurée 2- L1 GE

4. Types de fonctions

Il existe quatre principaux types de fonctions en C :

1. Fonction sans retour et sans paramètres :

C'est une fonction qui ne prend aucun paramètre et ne renvoie aucune valeur. On utilise
void comme type de retour.

Exemple :

void direBonjour() {
printf("Bonjour !\n");
}
int main() {
direBonjour(); // Appel de la fonction
return 0;
}

2. Fonction sans retour mais avec des paramètres :

C'est une fonction qui prend des paramètres mais ne renvoie pas de valeur.

Exemple :

void afficherCarre(int n) {
printf("Le carré de %d est %d\n", n, n * n);
}
int main() {
afficherCarre(4); // Appel avec un paramètre
return 0;
}

3. Fonction avec retour mais sans paramètres

C'est une fonction qui ne prend pas de paramètres mais qui renvoie une valeur.

Mme. Imen AZZOUZ 3

Programmation Structurée 2- L1 GE

Exemple :

int donnerNombre() {
return 10;
}
int main() {
int nombre = donnerNombre(); // Appel de la fonction
et stockage du retour
printf("Le nombre est %d\n", nombre);
return 0;
}

4. Fonction avec retour et avec paramètres

C'est une fonction qui prend des paramètres et renvoie une valeur.

Exemple :

int additionner(int a, int b) {

return a + b;
}
int main() {
int somme = additionner(5, 7); // Appel avec deux
paramètres
printf("La somme est %d\n", somme);
return 0;
}

5. Passage de paramètres par valeur

Dans les fonctions sans pointeurs, les paramètres sont passés par valeur, ce qui signifie que
la fonction reçoit une copie des arguments passés, et non les variables elles-mêmes. Toute
modification apportée aux paramètres n'affectera pas les variables originales dans la fonction
appelante.

Mme. Imen AZZOUZ 4

Programmation Structurée 2- L1 GE

Exemple :

#include <stdio.h>

void incrementer(int x) {
x = x + 1;
printf("Valeur de x dans la fonction : %d\n", x);
}
int main() {
int nombre = 5;
incrementer(nombre); // Appel avec une copie de `nombre`
printf("Valeur de nombre dans main : %d\n", nombre); //
`nombre` reste 5
return 0;
}

Dans cet exemple, bien que la valeur de x soit incrémentée dans la fonction incrementer, la
variable nombre dans la fonction main ne change pas, car x est une copie de nombre.

6. Exemples d'utilisation

Exemple 1 : Calcul de la somme de deux nombres

#include <stdio.h>
int somme(int a, int b) {
return a + b;
}
int main() {
int x = 10, y = 20;
int resultat = somme(x, y); // Appel de la fonction avec
deux paramètres
printf("La somme est : %d\n", resultat);
return 0;
}

Mme. Imen AZZOUZ 5

Programmation Structurée 2- L1 GE

Exemple 2 : Calcul de l'aire d'un rectangle

#include <stdio.h>
int calculerAire(int longueur, int largeur) {
return longueur * largeur;
}
int main() {
int l = 5, L = 10;
int aire = calculerAire(L, l);
printf("L'aire du rectangle est : %d\n", aire);
return 0;
}

7. Récursivité

Une fonction est dite récursive lorsqu'elle s'appelle elle-même. La récursivité est utile pour
résoudre certains types de problèmes comme le calcul de la factorielle, la recherche dans un
arbre, etc.

Exemple : Factorielle d'un nombre

#include <stdio.h>
int factorielle(int n) {
if (n == 0) {
return 1;
}
return n * factorielle(n - 1); // Appel récursif
}
int main() {
int nombre = 5;
printf("La factorielle de %d est %d\n", nombre,
factorielle(nombre));
return 0;
}

Dans cet exemple, la fonction factorielle s'appelle elle-même jusqu'à atteindre la condition

Mme. Imen AZZOUZ 6

Programmation Structurée 2- L1 GE

de base n == 0, où elle retourne 1. La valeur de retour est ensuite multipliée de manière

récursive jusqu'à la valeur finale.

Conclusion

Les fonctions sans pointeurs en C permettent de structurer un programme en tâches simples,

tout en conservant l'intégrité des variables dans la fonction principale (grâce au passage par
valeur). Elles sont essentielles pour la modularité du code et favorisent la réutilisation. En
maîtrisant les fonctions, on peut écrire des programmes plus lisibles, mieux organisés et plus
faciles à maintenir.

Mme. Imen AZZOUZ 7

Programmation Structurée 2- L1 GE

Chapitre 3 : Les fichiers

1. Introduction aux fichiers en C

En C, les fichiers sont utilisés pour stocker des données sur des supports de stockage externe
comme un disque dur. Contrairement aux variables qui disparaissent à la fin du programme,
les fichiers permettent de sauvegarder les informations de manière permanente.

2. Types de fichiers

Il existe deux types de fichiers :

Fichiers texte : Contiennent des données sous forme de texte lisible. Chaque ligne est une
chaîne de caractères terminée par un caractère de nouvelle ligne \n.

Fichiers binaires : Contiennent des données dans un format binaire qui n’est pas directement
lisible.

3. Opérations de base sur les fichiers

Les principales opérations sur les fichiers sont :

1. Ouvrir un fichier
2. Lire et écrire dans un fichier
3. Fermer un fichier

4. Ouvrir un fichier

Pour ouvrir un fichier, nous utilisons la fonction fopen. Elle prend deux arguments : le nom
du fichier et le mode d’ouverture.

Voici les modes d'ouverture les plus courants :

 "r" : Ouvre le fichier en lecture seule. Le fichier doit exister.

 "w" : Ouvre le fichier en écriture seule. Si le fichier n'existe pas, il est créé. Si le
fichier existe, son contenu est effacé.

Mme. Imen AZZOUZ 1

Programmation Structurée 2- L1 GE

 "a" : Ouvre le fichier en mode ajout (append). Les données sont ajoutées à la fin du
fichier.
 "r+" : Ouvre le fichier en lecture et écriture. Le fichier doit exister.
 "w+" : Ouvre le fichier en lecture et écriture. Si le fichier existe, son contenu est
effacé.
 "a+" : Ouvre le fichier en lecture et écriture, et les écritures se font à la fin du fichier.

Exemple pour ouvrir un fichier en lecture :

FILE *fichier = fopen("mon_fichier.txt", "r");

if (fichier == NULL) {

printf("Impossible d'ouvrir le fichier.\n");

5. Lire et écrire dans un fichier

5.1 Lecture

Pour lire des données dans un fichier, nous utilisons des fonctions comme fscanf pour lire
des données formatées et fgets pour lire une chaîne de caractères.

 fscanf : Fonction similaire à scanf mais utilisée pour lire dans un fichier.

Exemple :

FILE *fichier = fopen("mon_fichier.txt", "r");

int nombre;

fscanf(fichier, "%d", &nombre); // Lit un entier depuis le fichier

fclose(fichier);

 fgets : Pour lire une ligne ou une chaîne de caractères.

Mme. Imen AZZOUZ 2

Programmation Structurée 2- L1 GE

Exemple :

FILE *fichier = fopen("mon_fichier.txt", "r");

char ligne[100];

fgets(ligne, 100, fichier); // Lit une ligne depuis le fichier

printf("Contenu du fichier : %s", ligne);

fclose(fichier);

5.2 Écriture

Pour écrire dans un fichier, on peut utiliser fprintf pour les données formatées et fputs
pour les chaînes de caractères.

 fprintf : Fonction similaire à printf, mais pour écrire dans un fichier.

Exemple :

FILE *fichier = fopen("mon_fichier.txt", "w");

fprintf(fichier, "Ceci est un test. Le nombre est %d\n", 42);

fclose(fichier);

 fputs : Pour écrire une chaîne de caractères dans un fichier.

Exemple :

FILE *fichier = fopen("mon_fichier.txt", "w");

fputs("Une simple ligne de texte.\n", fichier);

fclose(fichier);

Mme. Imen AZZOUZ 3

Programmation Structurée 2- L1 GE

6. Exemple complet : Lecture et écriture

Voici un exemple de programme complet qui écrit des données dans un fichier et les relit.

#include <stdio.h>

int main() {

FILE *fichier;

// Écriture dans le fichier

fichier = fopen("[Link]", "w");

if (fichier == NULL) {

printf("Erreur d'ouverture du fichier en écriture.\n");

return 1;

fprintf(fichier, "Nom: Imen Azzouz\n");

fprintf(fichier, "Âge: 30\n");

fclose(fichier);

// Lecture du fichier

fichier = fopen("[Link]", "r");

if (fichier == NULL) {

printf("Erreur d'ouverture du fichier en lecture.\n");

return 1;

Mme. Imen AZZOUZ 4

Programmation Structurée 2- L1 GE

char ligne[100];

while (fgets(ligne, 100, fichier) != NULL) {

printf("%s", ligne); // Affiche chaque ligne lue

fclose(fichier);

return 0;

Mme. Imen AZZOUZ 5

TD Programmation Structurée 2- L1 GE

Travail Dirigé N° 1

Exercice 1 : Structure simple pour stocker les informations d'une personne

Définissez une structure Personne avec les membres suivants : nom, âge et taille. Demandez
à l'utilisateur de remplir les informations pour une personne, puis affichez-les.

Exercice 2 : Tableau de structures pour gérer des étudiants

Définissez une structure Etudiant avec les membres suivants : nom, âge, et moyenne. Créez
un tableau de 2 étudiants et demandez à l'utilisateur de saisir les informations pour chaque
étudiant, puis affichez-les.

Exercice 3 : Structure avec une date

Créez une structure Date avec les membres jour, mois et année. Demandez à l'utilisateur
d'entrer une date et affichez-la sous la forme "JJ/MM/AAAA".

Exercice 4 : Structure imbriquée

Définissez deux structures : Adresse avec les membres rue et numéro, et Personne avec
les membres nom, âge et une adresse (structure Adresse). Saisissez et affichez les
informations d'une personne et de son adresse.

Exercice 5 : Structure pour un livre

Définissez une structure Livre avec les membres titre, auteur et prix. Saisissez les
informations pour un livre et affichez-les.

Exercice 6 : Gestion des produits

Créez une structure Produit qui contient les membres suivants :

 nom (chaine de caractères),

 prix (flottant),

Mme. Imen AZZOUZ 1

TD Programmation Structurée 2- L1 GE

 quantite (entier).

Le programme doit :

1. Saisir les informations pour 3 produits.

2. Afficher ces informations.
3. Calculer et afficher la valeur totale des produits (prix * quantité pour chaque produit).

Mme. Imen AZZOUZ 2

TD Programmation Structurée 2- L1 GE

Travail Dirigé N° 2

Exercice 1 : Calcul de la somme de deux entiers

Écrire une fonction somme qui prend deux entiers en paramètres et retourne leur somme.

Exercice 2 : Calcul du carré d'un nombre

Écrire une fonction carre qui prend un entier en paramètre et retourne son carré.

Exercice 3 : Calcul de la factorielle

Écrire une fonction factorielle qui prend un entier en paramètre et retourne sa factorielle.

Exercice 4 : Trouver le maximum de trois nombres

Écrire une fonction maximum qui prend trois entiers en paramètres et retourne le plus grand
d'entre eux.

Exercice 5 : Inverser un entier

Écrire une fonction inverse qui prend un entier en paramètre et retourne son inverse (par
exemple, si l'entrée est 123, la sortie doit être 321).

Exercice 6 : Calcul de la somme, du produit et de la différence de deux

nombres

Écrire un programme qui contient trois fonctions :

 somme : pour calculer la somme de deux entiers.

 produit : pour calculer le produit de deux entiers.
 difference : pour calculer la différence entre deux entiers.

Mme. Imen AZZOUZ 1

TD Programmation Structurée 2- L1 GE

Exercice 7 : Opérations sur les nombres pairs

Écrire un programme qui contient trois fonctions :

est_pair : pour vérifier si un nombre est pair.

somme_paires : pour calculer la somme de deux nombres si les deux sont pairs.

produit_paires : pour calculer le produit de deux nombres si les deux sont pairs.

Exercice 8 : Vérification et calcul d'un nombre premier

Écrire un programme qui contient deux fonctions :

 est_premier : pour vérifier si un nombre est premier.

 afficher_premiers : pour afficher tous les nombres premiers jusqu'à un certain
nombre.

Mme. Imen AZZOUZ 2

TD Programmation Structurée 2- L1 GE

Travail Dirigé N° 3

Exercice 1 : Écrire et lire dans un fichier texte

Écrire un programme qui permet à l'utilisateur de saisir son nom et son âge, puis de les
enregistrer dans un fichier texte appelé [Link]. Ensuite, le programme doit relire
et afficher ces informations.

Exercice 2 : Copier le contenu d'un fichier vers un autre

Écrire un programme qui copie le contenu d'un fichier source appelé [Link] vers un
fichier de destination appelé [Link].

Exercice 3 : Compter le nombre de lignes, de mots et de caractères dans un

fichier

Écrire un programme qui ouvre un fichier texte appelé [Link] et compte le nombre de
lignes, de mots et de caractères dans le fichier.

Exercice 4 : Fusionner deux fichiers texte

Écrire un programme qui lit deux fichiers texte [Link] et [Link], puis
fusionne leur contenu dans un fichier appelé [Link].

Mme. Imen AZZOUZ 1

Correction TD Programmation Structurée 2- L1 GE

Correction Travail Dirigé N° 1

Exercice 1 : Structure simple pour stocker les informations d'une personne

Définissez une structure Personne avec les membres suivants : nom, âge et taille. Demandez
à l'utilisateur de remplir les informations pour une personne, puis affichez-les.

Solution :

#include <stdio.h>

struct Personne {

char nom[50];

int age;

float taille;

};

int main() {

struct Personne p;

// Saisie des informations

printf("Entrez le nom de la personne : ");

scanf("%s", &[Link]);

printf("Entrez l'âge de la personne : ");

scanf("%d", &[Link]);

printf("Entrez la taille de la personne (en mètres) : ");

scanf("%f", &[Link]) ;

Mme. Imen AZZOUZ 1

Correction TD Programmation Structurée 2- L1 GE

// Affichage des informations

printf("\nInformations de la personne :\n");

printf("Nom : %s\n", [Link]);

printf("Âge : %d\n", [Link]);

printf("Taille : %.2f mètres\n", [Link]);

return 0;

Exercice 2 : Tableau de structures pour gérer des étudiants

Définissez une structure Etudiant avec les membres suivants : nom, âge, et moyenne. Créez
un tableau de 2 étudiants et demandez à l'utilisateur de saisir les informations pour chaque
étudiant, puis affichez-les.

Solution :
#include <stdio.h>

struct Etudiant {

char nom[50];

int age;

float moyenne;

};

int main() {

struct Etudiant etudiants[2];

// Saisie des informations des étudiants

for (int i = 0; i < 2; i++) {

printf("Entrez le nom de l'étudiant %d : ", i + 1);

scanf("%s", etudiants[i].nom);

printf("Entrez l'âge de l'étudiant %d : ", i + 1);

Mme. Imen AZZOUZ 2

Correction TD Programmation Structurée 2- L1 GE

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

printf("Entrez la moyenne de l'étudiant %d : ", i + 1);

scanf("%f", &etudiants[i].moyenne);

// Affichage des informations des étudiants

printf("\nInformations des étudiants :\n");

for (int i = 0; i < 2; i++) {

printf("Étudiant %d :\n", i + 1);

printf("Nom : %s\n", etudiants[i].nom);

printf("Âge : %d\n", etudiants[i].age);

printf("Moyenne : %.2f\n", etudiants[i].moyenne);

printf("\n");

return 0;

Exercice 3 : Structure avec une date

Créez une structure Date avec les membres jour, mois et année. Demandez à l'utilisateur
d'entrer une date et affichez-la sous la forme "JJ/MM/AAAA".

Solution :
#include <stdio.h>

struct Date {

int jour;

int mois;

int annee;

};

Mme. Imen AZZOUZ 3

Correction TD Programmation Structurée 2- L1 GE

int main() {

struct Date date;

// Saisie de la date

printf("Entrez le jour : ");

scanf("%d", &[Link]);

printf("Entrez le mois : ");

scanf("%d", &[Link]);

printf("Entrez l'année : ");

scanf("%d", &[Link]);

// Affichage de la date

printf("La date saisie est : %02d/%02d/%d\n", [Link], [Link], [Link]);

return 0;

Exercice 4 : Structure imbriquée

Définissez deux structures : Adresse avec les membres rue et numéro, et Personne avec les
membres nom, âge et une adresse (structure Adresse). Saisissez et affichez les informations
d'une personne et de son adresse.

Solution :
#include <stdio.h>

// Structure pour l'adresse

struct Adresse {

char rue[50];

int numero;

};

// Structure pour la personne, qui contient une adresse

Mme. Imen AZZOUZ 4

Correction TD Programmation Structurée 2- L1 GE

struct Personne {

char nom[50];

int age;

struct Adresse adresse; // Structure imbriquée

};

int main() {

struct Personne p;

// Saisie des informations de la personne

printf("Entrez le nom : ");

scanf("%s", [Link]);

printf("Entrez l'âge : ");

scanf("%d", &[Link]);

// Saisie de l'adresse

printf("Entrez la rue : ");

scanf("%s", [Link]);

printf("Entrez le numéro de la rue : ");

scanf("%d", &[Link]);

// Affichage des informations de la personne et de son adresse

printf("\nInformations de la personne :\n");

printf("Nom : %s\n", [Link]);

printf("Âge : %d\n", [Link]);

Mme. Imen AZZOUZ 5

Correction TD Programmation Structurée 2- L1 GE

printf("Adresse : %d, %s\n", [Link], [Link]);

return 0;

Exercice 5 : Structure pour un livre

Définissez une structure Livre avec les membres titre, auteur et prix. Saisissez les
informations pour un livre et affichez-les.

Mme. Imen AZZOUZ 6

Correction TD Programmation Structurée 2- L1 GE

Solution :

#include <stdio.h>

struct Livre {

char titre[50];

char auteur[50];

float prix;

};

int main() {

struct Livre livre;

// Saisie des informations du livre

printf("Entrez le titre du livre : ");

scanf("%s", [Link]);

printf("Entrez l'auteur du livre : ");

scanf("%s", [Link]);

printf("Entrez le prix du livre : ");

scanf("%f", &[Link]);

// Affichage des informations du livre

printf("\nInformations du livre :\n");

printf("Titre : %s\n", [Link]);

printf("Auteur : %s\n", [Link]);

printf("Prix : %.2f\n", [Link]);

return 0; }

Mme. Imen AZZOUZ 7

Correction TD Programmation Structurée 2- L1 GE

Exercice 6 : Gestion des produits

Créez une structure Produit qui contient les membres suivants :

 nom (chaine de caractères),

 prix (flottant),
 quantite (entier).

Le programme doit :

1. Saisir les informations pour 3 produits.

2. Afficher ces informations.
3. Calculer et afficher la valeur totale des produits (prix * quantité pour chaque produit).

Solution :

#include <stdio.h>

// Structure pour un produit

struct Produit {

char nom[50];

float prix;

int quantite;

};

int main() {

struct Produit produits[3]; // Tableau pour 3 produits

float valeurTotale = 0; // Variable pour stocker la valeur totale

// Saisie des informations pour chaque produit

Mme. Imen AZZOUZ 8

Correction TD Programmation Structurée 2- L1 GE

for (int i = 0; i < 3; i++) {

printf("Entrez le nom du produit %d : ", i + 1);

scanf("%s", produits[i].nom);

printf("Entrez le prix du produit %d : ", i + 1);

scanf("%f", &produits[i].prix);

printf("Entrez la quantité du produit %d : ", i + 1);

scanf("%d", &produits[i].quantite);

printf("\n");

// Affichage des informations des produits et calcul de la valeur totale

printf("Informations des produits :\n");

for (int i = 0; i < 3; i++) {

printf("Produit %d :\n", i + 1);

printf("Nom : %s\n", produits[i].nom);

printf("Prix : %.2f\n", produits[i].prix);

printf("Quantité : %d\n", produits[i].quantite);

// Calcul de la valeur totale (prix * quantité pour chaque produit)

Mme. Imen AZZOUZ 9

Correction TD Programmation Structurée 2- L1 GE

valeurTotale += produits[i].prix * produits[i].quantite;

printf("Valeur du produit : %.2f\n", produits[i].prix * produits[i].quantite);

printf("\n");

// Affichage de la valeur totale de tous les produits

printf("Valeur totale des produits : %.2f\n", valeurTotale);

return 0;

Mme. Imen AZZOUZ 10

Correction TD Programmation Structurée 2- L1 GE

Correction Travail Dirigé N° 2

Exercice 1 : Calcul de la somme de deux entiers

Écrire une fonction somme qui prend deux entiers en paramètres et retourne leur somme.

Solution :
#include <stdio.h>

int somme(int a, int b) {

return a + b;

int main() {

int x = 5, y = 10;

int resultat = somme(x, y);

printf("La somme de %d et %d est: %d\n", x, y, resultat);

return 0;

Exercice 2 : Calcul du carré d'un nombre

Écrire une fonction carre qui prend un entier en paramètre et retourne son carré.

Solution :

#include <stdio.h>

int carre(int n) {

return n * n;

int main() {

Mme. Imen AZZOUZ 1

Correction TD Programmation Structurée 2- L1 GE

int nombre = 6;

printf("Le carré de %d est: %d\n", nombre, carre(nombre));

return 0;

Exercice 3 : Calcul de la factorielle

Écrire une fonction factorielle qui prend un entier en paramètre et retourne sa factorielle.

Solution :

#include <stdio.h>

int factorielle(int n) {

int resultat = 1;

for (int i = 1; i <= n; i++) {

resultat *= i;

return resultat;

int main() {

int nombre = 5;

printf("La factorielle de %d est: %d\n", nombre, factorielle(nombre));

return 0;

Exercice 4 : Trouver le maximum de trois nombres

Écrire une fonction maximum qui prend trois entiers en paramètres et retourne le plus grand
d'entre eux.

Solution :

Mme. Imen AZZOUZ 2

Correction TD Programmation Structurée 2- L1 GE

#include <stdio.h>

int maximum(int a, int b, int c) {

int max = a;

if (b > max) {

max = b;

if (c > max) {

max = c;

return max;

int main() {

int x = 3, y = 7, z = 5;

printf("Le maximum de %d, %d et %d est: %d\n", x, y, z, maximum(x, y, z));

return 0;

Exercice 5 : Inverser un entier

Écrire une fonction inverse qui prend un entier en paramètre et retourne son inverse (par
exemple, si l'entrée est 123, la sortie doit être 321).

Solution :

#include <stdio.h>

int inverse(int n) {

int inv = 0;

while (n != 0) {

Mme. Imen AZZOUZ 3

Correction TD Programmation Structurée 2- L1 GE

inv = inv * 10 + n % 10;

n /= 10;

return inv;

int main() {

int nombre = 1234;

printf("L'inverse de %d est: %d\n", nombre, inverse(nombre));

return 0;

Exercice 6 : Calcul de la somme, du produit et de la différence de deux

nombres

Écrire un programme qui contient trois fonctions :

 somme : pour calculer la somme de deux entiers.

 produit : pour calculer le produit de deux entiers.
 difference : pour calculer la différence entre deux entiers.

Solution :

#include <stdio.h>

int somme(int a, int b) {

return a + b;

int produit(int a, int b) {

Mme. Imen AZZOUZ 4

Correction TD Programmation Structurée 2- L1 GE

return a * b;

int difference(int a, int b) {

return a - b;

int main() {

int x = 8, y = 5;

printf("Somme de %d et %d: %d\n", x, y, somme(x, y));

printf("Produit de %d et %d: %d\n", x, y, produit(x, y));

printf("Différence entre %d et %d: %d\n", x, y, difference(x, y));

return 0;

Exercice 7 : Opérations sur les nombres pairs

Écrire un programme qui contient trois fonctions :

est_pair : pour vérifier si un nombre est pair.

somme_paires : pour calculer la somme de deux nombres si les deux sont pairs.

produit_paires : pour calculer le produit de deux nombres si les deux sont pairs.

Solution :

#include <stdio.h>

Mme. Imen AZZOUZ 5

Correction TD Programmation Structurée 2- L1 GE

int est_pair(int n) {

return n % 2 == 0;

int somme_paires(int a, int b) {

if (est_pair(a) && est_pair(b)) {

return a + b;

} else {

return -1; // Indiquer que l'un des nombres n'est pas pair

int produit_paires(int a, int b) {

if (est_pair(a) && est_pair(b)) {

return a * b;

} else {

return -1; // Indiquer que l'un des nombres n'est pas pair

int main() {

int x = 4, y = 6;

Mme. Imen AZZOUZ 6

Correction TD Programmation Structurée 2- L1 GE

if (somme_paires(x, y) != -1) {

printf("La somme des nombres pairs %d et %d est: %d\n", x, y, somme_paires(x, y));

} else {

printf("L'un des nombres n'est pas pair.\n");

if (produit_paires(x, y) != -1) {

printf("Le produit des nombres pairs %d et %d est: %d\n", x, y, produit_paires(x, y));

} else {

printf("L'un des nombres n'est pas pair.\n");

return 0;

Exercice 8 : Vérification et calcul d'un nombre premier

Écrire un programme qui contient deux fonctions :

 est_premier : pour vérifier si un nombre est premier.

 afficher_premiers : pour afficher tous les nombres premiers jusqu'à un certain
nombre.

Solution :

#include <stdio.h>

int est_premier(int n) {

Mme. Imen AZZOUZ 7

Correction TD Programmation Structurée 2- L1 GE

if (n <= 1) return 0;

for (int i = 2; i <= n/2; i++) {

if (n % i == 0) return 0;

return 1;

void afficher_premiers(int max) {

for (int i = 2; i <= max; i++) {

if (est_premier(i)) {

printf("%d ", i);

printf("\n");

int main() {

int max = 20;

printf("Les nombres premiers jusqu'à %d sont :\n", max);

afficher_premiers(max);

return 0; }

Mme. Imen AZZOUZ 8

Correction TD Programmation Structurée 2- L1 GE

Exercice 9 : Calcul de la moyenne, du maximum et du minimum d'un tableau

Écrire un programme qui contient trois fonctions :

moyenne : pour calculer la moyenne des éléments d'un tableau.

maximum : pour trouver le maximum dans un tableau.

minimum : pour trouver le minimum dans un tableau.

Solution :

#include <stdio.h>

float moyenne(int tab[], int taille) {

int somme = 0;

for (int i = 0; i < taille; i++) {

somme += tab[i];

return (float)somme / taille;

int maximum(int tab[], int taille) {

int max = tab[0];

for (int i = 1; i < taille; i++) {

if (tab[i] > max) {

max = tab[i];

Mme. Imen AZZOUZ 9

Correction TD Programmation Structurée 2- L1 GE

return max;

int minimum(int tab[], int taille) {

int min = tab[0];

for (int i = 1; i < taille; i++) {

if (tab[i] < min) {

min = tab[i];

return min;

int main() {

int tableau[] = {12, 45, 22, 8, 36};

int taille = sizeof(tableau) / sizeof(tableau[0]);

printf("Moyenne des éléments du tableau : %.2f\n", moyenne(tableau, taille));

printf("Maximum dans le tableau : %d\n", maximum(tableau, taille));

printf("Minimum dans le tableau : %d\n", minimum(tableau, taille)); return 0;}

Mme. Imen AZZOUZ 10

Correction TD Programmation Structurée 2- L1 GE

Correction Travail Dirigé N° 3

Exercice 1 : Écrire et lire dans un fichier texte

Écrire un programme qui permet à l'utilisateur de saisir son nom et son âge, puis de les
enregistrer dans un fichier texte appelé [Link]. Ensuite, le programme doit relire et
afficher ces informations.

Solution :

#include <stdio.h>

int main() {

FILE *fichier;

char nom[50];

int age;

// Saisie des informations de l'utilisateur

printf("Entrez votre nom : ");

scanf("%s", nom);

printf("Entrez votre âge : ");

scanf("%d", &age);

// Écriture des informations dans le fichier

fichier = fopen("[Link]", "w");

if (fichier == NULL) {

printf("Erreur d'ouverture du fichier.\n");

return 1;

fprintf(fichier, "Nom: %s\n", nom);

fprintf(fichier, "Âge: %d\n", age);

fclose(fichier);

Mme. Imen AZZOUZ 1

Correction TD Programmation Structurée 2- L1 GE

// Lecture et affichage des informations à partir du fichier

fichier = fopen("[Link]", "r");

if (fichier == NULL) {

printf("Erreur d'ouverture du fichier.\n");

return 1;

char ligne[100];

while (fgets(ligne, 100, fichier) != NULL) {

printf("%s", ligne); // Affichage de chaque ligne lue

fclose(fichier);

return 0;

Exercice 2 : Copier le contenu d'un fichier vers un autre

Écrire un programme qui copie le contenu d'un fichier source appelé [Link] vers un
fichier de destination appelé [Link].

Solution :

#include <stdio.h>

int main() {

FILE *source, *destination;

char caractere;

// Ouverture du fichier source en lecture

source = fopen("[Link]", "r");

if (source == NULL) {

Mme. Imen AZZOUZ 2

Correction TD Programmation Structurée 2- L1 GE

printf("Erreur d'ouverture du fichier source.\n");

return 1;

// Ouverture du fichier destination en écriture

destination = fopen("[Link]", "w");

if (destination == NULL) {

printf("Erreur d'ouverture du fichier destination.\n");

fclose(source); // Fermer le fichier source en cas d'erreur

return 1;

// Copie des caractères du fichier source vers le fichier destination

while ((caractere = fgetc(source)) != EOF) {

fputc(caractere, destination);

printf("Le contenu du fichier a été copié avec succès.\n");

// Fermeture des fichiers

fclose(source);

fclose(destination);

return 0;

Exercice 3 : Compter le nombre de lignes, de mots et de caractères dans un

fichier

Écrire un programme qui ouvre un fichier texte appelé [Link] et compte le nombre de

Mme. Imen AZZOUZ 3

Correction TD Programmation Structurée 2- L1 GE

lignes, de mots et de caractères dans le fichier.

Solution :

#include <stdio.h>

#include <ctype.h>

int main() {

FILE *fichier;

char caractere;

int nb_lignes = 0, nb_mots = 0, nb_caracteres = 0;

int dans_mot = 0; // Indicateur si on est dans un mot ou non

// Ouverture du fichier en lecture

fichier = fopen("[Link]", "r");

if (fichier == NULL) {

printf("Erreur d'ouverture du fichier.\n");

return 1;

// Lecture caractère par caractère

while ((caractere = fgetc(fichier)) != EOF) {

nb_caracteres++;

if (caractere == '\n') {

Mme. Imen AZZOUZ 4

Correction TD Programmation Structurée 2- L1 GE

nb_lignes++;

if (isspace(caractere)) {

dans_mot = 0;

} else if (!dans_mot) {

dans_mot = 1;

nb_mots++;

// Si le fichier n'est pas vide, il y a au moins une ligne

if (nb_caracteres > 0) {

nb_lignes++;

// Affichage des résultats

printf("Nombre de lignes : %d\n", nb_lignes);

printf("Nombre de mots : %d\n", nb_mots);

printf("Nombre de caractères : %d\n", nb_caracteres);

fclose(fichier);

return 0;

Mme. Imen AZZOUZ 5

Correction TD Programmation Structurée 2- L1 GE

Exercice 4 : Fusionner deux fichiers texte

Écrire un programme qui lit deux fichiers texte [Link] et [Link], puis
fusionne leur contenu dans un fichier appelé [Link].

Solution :

#include <stdio.h>

int fusionner_fichiers(const char *fichier1, const char *fichier2, const char *fichierFusion) {

FILE *f1, *f2, *fusion;

char caractere;

// Ouverture du premier fichier en lecture

f1 = fopen(fichier1, "r");

if (f1 == NULL) {

printf("Erreur d'ouverture du fichier %s.\n", fichier1);

return 1;

// Ouverture du deuxième fichier en lecture

f2 = fopen(fichier2, "r");

if (f2 == NULL) {

printf("Erreur d'ouverture du fichier %s.\n", fichier2);

fclose(f1); // Fermer le premier fichier en cas d'erreur

Mme. Imen AZZOUZ 6

Correction TD Programmation Structurée 2- L1 GE

return 1;

// Ouverture du fichier fusion en écriture

fusion = fopen(fichierFusion, "w");

if (fusion == NULL) {

printf("Erreur d'ouverture du fichier %s.\n", fichierFusion);

fclose(f1);

fclose(f2);

return 1;

// Copier le contenu du premier fichier dans le fichier fusion

while ((caractere = fgetc(f1)) != EOF) {

fputc(caractere, fusion);

// Copier le contenu du deuxième fichier dans le fichier fusion

while ((caractere = fgetc(f2)) != EOF) {

fputc(caractere, fusion);

printf("La fusion des fichiers a été effectuée avec succès.\n");

Mme. Imen AZZOUZ 7

Correction TD Programmation Structurée 2- L1 GE

// Fermeture des fichiers

fclose(f1);

fclose(f2);

fclose(fusion);

return 0;

int main() {

fusionner_fichiers("[Link]", "[Link]", "[Link]");

return 0;

Mme. Imen AZZOUZ 8