Algorithmique et Programmation C++

TD6 : Allocation dynamique, structure de données, fichiers

2023-2024

Exercice 1 : Allocation dynamique de la mémoire

Une matrice nilpotente est une matrice carrée dont une certaine puissance est une matrice nulle.
Autrement dit, une matrice A est dite nilpotente si 𝐴𝑘 = 0 pour une certaine puissance positive k. En
d'autres termes, en répétant la multiplication de la matrice par elle-même, on finit par obtenir une
matrice nulle. Le plus petit k qui vérifier la condition 𝐴𝑘 = 0 est appelé l'Indice de nilpotent.

Dans le programme principal suivant, une matrice carrée A d'ordre N = 10 est déclarée.

1. Implémenter la fonction int** initMatrice(int n) qui permet de retourner une matrice

triangulaire inférieure remplie de valeurs aléatoires entre 0 et 10 (utiliser la fonction rand () de la
bibliothèque stdlib qui génère une valeur aléatoire entier) pour qu’elle soit triangulaire inférieure.
2. Implémentez la fonction int** produitMatrices(int **M, int **N, int n) qui retourne le produit
des deux matrices M et N passée comme argument.
3. Donner le code de la fonction isNulle qui retourne 1 si la matrice d’ordre N prise comme
paramètre est nulle et 0 sinon.
4. Écrire la fonction nilpotenceIndice pour déterminer l'indice de nilpotent de la matrice A carrée
d’ordre N prise comme paramètre.
5. Modifions le code du programme principal pour permettre à l'utilisateur de saisir une valeur
entière à chaque itération. Ensuite, le programme vérifie si cette valeur correspond à l'indice
de nilpotent k de la matrice M. Si c'est le cas, le programme affiche le message 'Bonne réponse'
et se termine. Sinon, il affiche 'Votre réponse est incorrecte, veuillez saisir une autre valeur'.

Exercice 2 : Structure de données

1. Structures :
a. Date : Définissez une structure Date qui représente la date de publication d'un livre.
Cette structure aura trois champs : jour, mois, et année.
b. Auteur : Créez une structure Auteur qui représente un auteur. Un auteur a un nom et
un prénom.
c. Livre : Définissez une structure Livre qui représente un livre. Un livre a un titre, un
tableau statique d'auteurs, le nombre d'auteurs, un id (numéro d'identification
unique), et une datePublication (utilisant la structure Date).
2. Fonctions de création :
a. Créez une fonction creerAuteur qui prend le nom et le prénom d'un auteur en
paramètres, et retourne une structure Auteur nouvellement créée.
b. Créez une fonction creerLivre qui prend en paramètres le titre, un tableau statique
d'auteurs, le nombre d'auteurs, l'id, et la date de publication, et retourne une
structure Livre nouvellement créée.
3. Gestion de la bibliothèque :
a. Définissez une structure Bibliotheque qui contient un tableau statique de livres (Livre
livres[MAX_LIVRES] où MAX_LIVRES est la taille maximale du tableau).
b. Écrivez une fonction ajouterLivre qui prend une bibliothèque et un livre en
paramètres, et ajoute ce livre à la bibliothèque si l'espace est disponible.

1
 c. Écrivez une fonction afficherBibliotheque qui prend une bibliothèque en paramètre
et affiche tous les livres qu'elle contient, en incluant les informations sur les auteurs.
d. Écrivez une fonction rechercherParAuteur qui prend une bibliothèque et le nom d'un
auteur en paramètres, et renvoie un tableau statique des livres écrits par cet auteur
dans la bibliothèque.
e. Écrivez une fonction rechercherLivre à votre code pour permettre la recherche d'un
livre dans la bibliothèque.
4. Programme principal (main) :
a. Dans la fonction principale (main), créez une bibliothèque.
b. Ajoutez quelques auteurs et créez quelques livres avec plusieurs auteurs.
c. Ajoutez les livres à la bibliothèque à l'aide de la fonction ajouterLivre.
d. Affichez la bibliothèque en utilisant la fonction afficherBibliotheque.
e. Effectuez une recherche par auteur à l'aide de la fonction rechercherParAuteur.

Exercice 3 : Fichiers en C/C++

1. Objectif :
a. Le but de cet exercice est de manipuler des fichiers en C/C++ en effectuant des
opérations d'écriture, de lecture et de recherche.
2. Création de Fichiers :
a. Écrivez une fonction en C/C++ qui crée un fichier texte appelé "mon_fichier.txt" et y
écrit quelques lignes de texte.
3. Lecture de Fichiers :
a. Écrivez une fonction qui lit le contenu du fichier "mon_fichier.txt" et l'affiche à l'écran.
4. Recherche de Mot :
a. Écrivez une fonction qui prend en entrée un mot, recherche ce mot dans le fichier
"mon_fichier.txt" et affiche le nombre d'occurrences du mot dans le fichier.
5. Modification de Fichier :
a. Écrivez une fonction qui ajoute une nouvelle ligne de texte à la fin du fichier
"mon_fichier.txt".
6. Suppression de Fichier :
a. Écrivez une fonction qui supprime le fichier "mon_fichier.txt".
7. Instructions :
a. Utilisez les fonctions d'entrée/sortie standard (fopen, fclose, fprintf, fscanf, etc.) pour
manipuler les fichiers.
b. Assurez-vous de gérer les erreurs liées à l'ouverture, la lecture, et l'écriture des
fichiers.
c. Le programme principal devrait appeler les fonctions que vous avez écrites et
démontrer leur fonctionnement.

2
Correction Exercice 2 :
#include <iostream>
#include <stdlib.h>
#include <iostream>
#include <cstdlib> // Pour rand()

const int MAX_VALEUR = 10;

int** initMatrice(int n) {
// Créer une matrice de taille n x n remplie de zéros
int** matrice = new int*[n];
for (int i = 0; i < n; ++i) {
matrice[i] = new int[n];
for (int j = 0; j < n; ++j) {
matrice[i][j] = 0;
}
}

// Remplir la matrice avec des valeurs aléatoires entre 0 et 10 en mode triangulaire inférieure
for (int i = 0; i < n; ++i) {
for (int j = 0; j < i; ++j) {
matrice[i][j] = std::rand() % (MAX_VALEUR + 1);
}
}

return matrice;
}
int** produitMatrices(int **M, int **N, int n) {
int** resultat = new int*[n];
for (int i = 0; i < n; ++i) {
resultat[i] = new int[n];
for (int j = 0; j < n; ++j) {
resultat[i][j] = 0;
for (int k = 0; k < n; ++k) {
resultat[i][j] += M[i][k] * N[k][j];
}
}
}
return resultat;
}

int isNulle(int** matrice, int n) {

for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (matrice[i][j] != 0) {
return 0; // La matrice n'est pas nulle
}
}
}
return 1; // La matrice est nulle
}

3
int nilpotenceIndice(int** matrice, int n) {
int indice = 1;
int** puissanceMatrice = matrice;

while (!isNulle(puissanceMatrice, n)) {

puissanceMatrice = produitMatrices(puissanceMatrice, matrice, n);
++indice;
}

return indice;
}

void afficherMatrice(int** matrice, int n) {

for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
std::cout << matrice[i][j] << " ";
}
std::cout << std::endl;
}
}

int main(){

int tailleMatrice;
std::cout << "Entrez la taille de la matrice : ";
std::cin >> tailleMatrice;

int** matrice = initMatrice(tailleMatrice);

int k;

afficherMatrice(matrice, tailleMatrice);
do {
std::cout << "Devinez l'indice de nilpotent k : ";
std::cin >> k;

if (k == nilpotenceIndice(matrice, tailleMatrice)) {
std::cout << "Bonne réponse!" << std::endl;
break;
} else {
std::cout << "Votre réponse est incorrecte, veuillez saisir une autre valeur." << std::endl;
}
} while (true);

// Libérer la mémoire allouée pour la matrice

for (int i = 0; i < tailleMatrice; ++i) {
delete[] matrice[i];
}
delete[] matrice;

return 0;
}
4
Correction Exercice 2 :
#include <iostream>
#include <string>
#include <cstring>

using namespace std;

const int MAX_AUTEURS = 5;

const int MAX_LIVRES = 10;

// Structure pour représenter la date de publication

struct Date {
int jour;
int mois;
int annee;
};

// Structure pour représenter un auteur

struct Auteur {
char nom[50];
char prenom[50];
};

// Structure pour représenter un livre

struct Livre {
char titre[100];
Auteur auteurs[MAX_AUTEURS];
int nombreAuteurs;
int id;
Date datePublication;
};

// Structure pour représenter une bibliothèque

struct Bibliotheque {
Livre livres[MAX_LIVRES];
int nombreLivres;
};

// Fonction pour créer un auteur

Auteur creerAuteur(const char* nom, const char* prenom) {
Auteur nouvelAuteur;
strncpy(nouvelAuteur.nom, nom, sizeof(nouvelAuteur.nom) - 1);
nouvelAuteur.nom[sizeof(nouvelAuteur.nom) - 1] = '\0'; // Assure une terminaison correcte de
la chaîne
strncpy(nouvelAuteur.prenom, prenom, sizeof(nouvelAuteur.prenom) - 1);
nouvelAuteur.prenom[sizeof(nouvelAuteur.prenom) - 1] = '\0'; // Assure une terminaison
correcte de la chaîne
return nouvelAuteur;
}

// Fonction pour créer un livre

5
Livre creerLivre(const char* titre, const Auteur auteurs[], int nombreAuteurs, int id, const Date&
datePublication) {
Livre nouveauLivre;
strncpy(nouveauLivre.titre, titre, sizeof(nouveauLivre.titre) - 1);
nouveauLivre.titre[sizeof(nouveauLivre.titre) - 1] = '\0'; // Assure une terminaison correcte de la
chaîne
for (int i = 0; i < nombreAuteurs; ++i) {
nouveauLivre.auteurs[i] = auteurs[i];
}
nouveauLivre.nombreAuteurs = nombreAuteurs;
nouveauLivre.id = id;
nouveauLivre.datePublication = datePublication;
return nouveauLivre;
}

// Fonction pour ajouter un livre à la bibliothèque

void ajouterLivre(Bibliotheque& bibliotheque, const Livre& livre) {
if (bibliotheque.nombreLivres < MAX_LIVRES) {
bibliotheque.livres[bibliotheque.nombreLivres++] = livre;
std::cout << "Livre ajouté à la bibliothèque." << std::endl;
} else {
std::cout << "La bibliothèque est pleine, impossible d'ajouter le livre." << std::endl;
}
}

// Fonction pour afficher la bibliothèque

void afficherBibliotheque(const Bibliotheque& bibliotheque) {
std::cout << "Bibliothèque :" << std::endl;
for (int i = 0; i < bibliotheque.nombreLivres; ++i) {
const Livre& livre = bibliotheque.livres[i];
std::cout << "Titre: " << livre.titre << std::endl;
std::cout << "Auteurs: ";
for (int j = 0; j < livre.nombreAuteurs; ++j) {
const Auteur& auteur = livre.auteurs[j];
std::cout << auteur.prenom << " " << auteur.nom;
if (j < livre.nombreAuteurs - 1) {
std::cout << ", ";
}
}
std::cout << std::endl;
std::cout << "ID: " << livre.id << std::endl;
std::cout << "Date de publication: " << livre.datePublication.jour << "/" <<
livre.datePublication.mois << "/" << livre.datePublication.annee << std::endl;
std::cout << "------------------------" << std::endl;
}
}

// Fonction pour rechercher les livres d'un auteur dans la bibliothèque

void rechercherParAuteur(const Bibliotheque& bibliotheque, const char* nomAuteur) {
std::cout << "Livres de l'auteur " << nomAuteur << " :" << std::endl;
for (int i = 0; i < bibliotheque.nombreLivres; ++i) {
const Livre& livre = bibliotheque.livres[i];
6
 for (int j = 0; j < livre.nombreAuteurs; ++j) {
const Auteur& auteur = livre.auteurs[j];
if (strcmp(auteur.nom, nomAuteur) == 0) {
std::cout << "Titre: " << livre.titre << std::endl;
std::cout << "Auteurs: ";
for (int k = 0; k < livre.nombreAuteurs; ++k) {
const Auteur& auteur = livre.auteurs[k];
std::cout << auteur.prenom << " " << auteur.nom;
if (k < livre.nombreAuteurs - 1) {
std::cout << ", ";
}
}
std::cout << std::endl;
std::cout << "ID: " << livre.id << std::endl;
std::cout << "Date de publication: " << livre.datePublication.jour << "/" <<
livre.datePublication.mois << "/" << livre.datePublication.annee << std::endl;
std::cout << "------------------------" << std::endl;
break; // Sortir de la boucle interne si l'auteur est trouvé
}
}
}
}

// Fonction pour rechercher un livre par titre

Livre& rechercherLivre(Bibliotheque& bibliotheque, const char* titre) {
for (int i = 0; i < bibliotheque.nombreLivres; ++i) {
if (strcmp(bibliotheque.livres[i].titre, titre) == 0) {
return bibliotheque.livres[i];
}
}
// Si le livre n'est pas trouvé, renvoie une référence vers un "livre vide"
static Livre livreVide;
return livreVide;
}

// Fonction pour rechercher les livres d'un auteur dans la bibliothèque

void livresParAuteur(const Bibliotheque& bibliotheque, const char* nomAuteur, Livre
livresTrouves[MAX_LIVRES], int& nombreLivresTrouves) {
nombreLivresTrouves = 0; // Initialiser le nombre de livres trouvés à 0

for (int i = 0; i < bibliotheque.nombreLivres; ++i) {

const Livre& livre = bibliotheque.livres[i];
for (int j = 0; j < livre.nombreAuteurs; ++j) {
const Auteur& auteur = livre.auteurs[j];
if (strcmp(auteur.nom, nomAuteur) == 0) {
livresTrouves[nombreLivresTrouves++] = livre;
break; // Sortir de la boucle interne si l'auteur est trouvé
}
}
}
}

7
int main() {
// Création d'une bibliothèque
Bibliotheque maBibliotheque;
maBibliotheque.nombreLivres = 0; // Initialiser le nombre de livres à 0

// Création de quelques auteurs

Auteur auteur1 = creerAuteur("Doe", "John");
Auteur auteur2 = creerAuteur("Smith", "Alice");

// Créez quelques livres avec plusieurs auteurs

Auteur auteursLivre1[] = {auteur1, auteur2};
Date dl1 = {1, 1, 2022};
Livre livre1 = creerLivre("Titre1", auteursLivre1, 2, 1, dl1);

Date dl2 = {2, 2, 2022};

Auteur auteursLivre2[] = {auteur2};
Livre livre2 = creerLivre("Titre2", auteursLivre2, 1, 2, dl2);

// Ajout des livres à la bibliothèque

ajouterLivre(maBibliotheque, livre1);
ajouterLivre(maBibliotheque, livre2);

// Affichage de la bibliothèque
afficherBibliotheque(maBibliotheque);

// Recherche par auteur

rechercherParAuteur(maBibliotheque, "Smith");

// Recherche de livre par titre

const char* titreRecherche = "Titre1";
Livre& livreTrouve = rechercherLivre(maBibliotheque, titreRecherche);

if (&livreTrouve != &maBibliotheque.livres[MAX_LIVRES]) {
std::cout << "Livre trouve :" << std::endl;
std::cout << "Titre: " << livreTrouve.titre << std::endl;
std::cout << "Auteurs: ";
for (int i = 0; i < livreTrouve.nombreAuteurs; ++i) {
std::cout << livreTrouve.auteurs[i].prenom << " " << livreTrouve.auteurs[i].nom;
if (i < livreTrouve.nombreAuteurs - 1) {
std::cout << ", ";
}
}
std::cout << std::endl;
std::cout << "ID: " << livreTrouve.id << std::endl;
std::cout << "Date de publication: " << livreTrouve.datePublication.jour << "/" <<
livreTrouve.datePublication.mois << "/" << livreTrouve.datePublication.annee << std::endl;
} else {
std::cout << "Livre non trouve." << std::endl;
}

// Recherche par auteur

const char* nomAuteurRecherche = "Smith";
8
 Livre livresTrouves[MAX_LIVRES];
int nombreLivresTrouves = 0;

livresParAuteur(maBibliotheque, nomAuteurRecherche, livresTrouves,

nombreLivresTrouves);

if (nombreLivresTrouves > 0) {
std::cout << "Livres de l'auteur " << nomAuteurRecherche << " :" << std::endl;
for (int i = 0; i < nombreLivresTrouves; ++i) {
std::cout << "Titre: " << livresTrouves[i].titre << std::endl;
// Afficher d'autres informations du livre si nécessaire
}
} else {
std::cout << "Aucun livre trouvé pour l'auteur " << nomAuteurRecherche << "." <<
std::endl;
}
return 0;
}

Correction Exercice 3 :
#include <iostream>
#include <string>
#include <cstring>

using namespace std;

// Création de Fichier
void creerFichier() {
FILE *fichier = fopen("mon_fichier.txt", "w");

if (fichier != NULL) {
fprintf(fichier, "Première ligne de texte.\n");
fprintf(fichier, "Deuxième ligne de texte.\n");

fclose(fichier);
printf("Fichier créé avec succès.\n");
} else {
printf("Erreur lors de la création du fichier.\n");
}
}

// Lecture de Fichier
void lireFichier() {
FILE *fichier = fopen("mon_fichier.txt", "r");

if (fichier != NULL) {
char ligne[100];

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

printf("%s", ligne);
}

9
 fclose(fichier);
} else {
printf("Erreur lors de la lecture du fichier.\n");
}
}

// Recherche de Mot
void rechercherMot(const char *mot) {
FILE *fichier = fopen("mon_fichier.txt", "r");

if (fichier != NULL) {
char motCourant[100];
int occurrences = 0;

while (fscanf(fichier, "%s", motCourant) != EOF) {

if (strcmp(motCourant, mot) == 0) {
occurrences++;
}
}

printf("Le mot '%s' apparaît %d fois dans le fichier.\n", mot, occurrences);

fclose(fichier);
} else {
printf("Erreur lors de la lecture du fichier.\n");
}
}

// Modification de Fichier
void ajouterLigne() {
FILE *fichier = fopen("mon_fichier.txt", "a");

if (fichier != NULL) {
fprintf(fichier, "Nouvelle ligne ajoutée à la fin du fichier.\n");
fclose(fichier);
printf("Ligne ajoutée avec succès.\n");
} else {
printf("Erreur lors de l'ajout de la ligne.\n");
}
}

// Suppression de Fichier
void supprimerFichier() {
if (remove("mon_fichier.txt") == 0) {
printf("Fichier supprimé avec succès.\n");
} else {
printf("Erreur lors de la suppression du fichier.\n");
}
}

int main() {
creerFichier();
10
 lireFichier();
rechercherMot("ligne");
ajouterLigne();
lireFichier();
supprimerFichier();

return 0;
}
#include <iostream>
#include <fstream>
#include <string>

// Création de Fichier
void creerFichier() {
std::ofstream fichier("mon_fichier.txt");

if (fichier.is_open()) {
fichier << "Première ligne de texte." << std::endl;
fichier << "Deuxième ligne de texte." << std::endl;

fichier.close();
std::cout << "Fichier créé avec succès." << std::endl;
} else {
std::cout << "Erreur lors de la création du fichier." << std::endl;
}
}

// Lecture de Fichier
void lireFichier() {
std::ifstream fichier("mon_fichier.txt");

if (fichier.is_open()) {
std::string ligne;

while (std::getline(fichier, ligne)) {

std::cout << ligne << std::endl;
}

fichier.close();
} else {
std::cout << "Erreur lors de la lecture du fichier." << std::endl;
}
}

// Recherche de Mot
void rechercherMot(const std::string &mot) {
std::ifstream fichier("mon_fichier.txt");

if (fichier.is_open()) {
std::string motCourant;
int occurrences = 0;

11
 while (fichier >> motCourant) {
if (motCourant == mot) {
occurrences++;
}
}

std::cout << "Le mot '" << mot << "' apparaît " << occurrences << " fois dans le fichier." <<
std::endl;

fichier.close();
} else {
std::cout << "Erreur lors de la lecture du fichier." << std::endl;
}
}

// Modification de Fichier
void ajouterLigne() {
std::ofstream fichier("mon_fichier.txt", std::ios::app);

if (fichier.is_open()) {
fichier << "Nouvelle ligne ajoutée à la fin du fichier." << std::endl;
fichier.close();
std::cout << "Ligne ajoutée avec succès." << std::endl;
} else {
std::cout << "Erreur lors de l'ajout de la ligne." << std::endl;
}
}

// Suppression de Fichier
void supprimerFichier() {
if (std::remove("mon_fichier.txt") == 0) {
std::cout << "Fichier supprimé avec succès." << std::endl;
} else {
std::cout << "Erreur lors de la suppression du fichier." << std::endl;
}
}

int main() {
creerFichier();
lireFichier();
rechercherMot("ligne");
ajouterLigne();
lireFichier();
supprimerFichier();

return 0;
}

12