Ce programme montre comment formater l'affichage en C++ : il affiche un entier en
hexadécimal avec un remplissage de `*`, fixe la largeur d'affichage et limite la précision pour un nombre décimal.
Exercice 1:
A -Ecrire un programme permettant de calculer et d’afficher sa valeur a l’écran pour des
valeurs fixées a, b et c
6 Apres exécution :
Ce programme calcule et affiche le discriminant de l'équation quadratique ax2+bx+c= 0 pour
des valeurs fixées de a, b et c. B- Compléter le programme précédent de manière a` pouvoir rentrer les valeurs de a, b et c au clavier. Compiler et tester
7 Apres exécution :
Ce programme utilise la fonction cin pour lire les variables a,b et c.
C- Calculez et afficher les solutions de l’équation dans le cas où le discriminant et positif
8 Apres exécution :
If (discriminant > 0) : Cette condition vérifie si le discriminant est positif.
Dans ce cas,
L’équation quadratique a deux solutions réelles distinctes (x1 et x2), qui sont alors calculées Et affichées.
9 Exercice 2 :
Ecrire un programme qui calcule les racines carrées de nombres fournis s en
donnée. Il s’arrêtera lorsqu’on lui fournira la valeur 0. Il refusera les valeurs négatives. Son exécution se présentera ainsi
Apres exécution :
Ce programme demande un nombre positif à l'utilisateur pour calculer sa racine
carrée, rejette les valeurs négatives, et se termine si l'utilisateur entre zéro, en travaillant par la boucle While .
10 Tp2 : LES TABLEAUX EN C++ : Exercice 1 :
Écrire un programme qui lit 10 nombres entiers dans un tableau avant d’en rechercher le plus grand et le plus petit
Exécution :
Ce code permet d’extraire le maximum et minimum d’un tableau de 10 lignes.
11 Exercice 2 :
Deux tableaux, T et U, contiennent chacun N nombres, tous compris entre 1 et 100.
Déterminer si les contenus de deux tableaux sont identiques.
Exécution :
Ce code permet le remplissage de 2 tableaux et de vérifier si ses 2 codes sont identiques ou
non.
12 Exercice 3 :
Soit le tableau t déclaré ainsi : float t[3] [4] ;Écrire les instructions permettant de calculer, dans une variable nommée som, la somme des éléments de t.
Exécution :
Ce code permet de calculer la somme des éléments du tableau.
13 TP3 : Les fonctions : Exercice 1 :
On a le programme à corriger est comme suivant :
Les corrections sont :
• L’ajout de type de retour pour la fonction main()
• L’absence d’une signature ou d’une déclaration de la fonction avant leur utilisation dans le programme principale.
14 Exercice 2 :
Exercice 3 :
1 er programme :
15 Commentaire :
Il s’agit d’une transmission par valeur, dans laquelle la fonction copie
uniquement la valeur de chacune de ces paramètres , et ne change pas l’état de ces variables originales . 2 -ème programme :
16 Commentaire : Ila s’agit d’une transmission par référence, permet à une fonction de créer des référence c-à-d des alias permanentes à ces paramètres de la fonction et de manipuler les variables originales.
3-ème programme :
Commentaire : Il s’agit d’une transmission par adresse, les fonctions manipule les variables originale et directement sans recourir à des alias ou des réference.
17 TP 3 : Les classes et les objets: Introduction :
Dans ce TP, nous allons explorer l'un des concepts fondamentaux de la programmation orientée objet (POO) : les classes et les objets. La POO est un paradigme de programmation qui permet de structurer un programme en regroupant les données et les comportements associés dans des entités appelées classes. En C++, les classes offrent une manière puissante et flexible de modéliser des objets du monde réel, facilitant ainsi la création de programmes modulaires, extensibles et réutilisables.
Exercice 1 :
Créer une classe Point contenant :
A -Deux attributs x et y de type entier.
B -Deux méthodes initialise et affiche.
2) Dans la fonction main de votre programme créer un objet « point1 » et
appeler les deux méthodes initialise et affiche.
3) Compiler le programme et expliquer le message d’erreur obtenu
18 Commentaire : L'erreur indiquée montre que le compilateur ne peut pas accéder aux fonctions initialise (int, int) et affiche () de la classe Point, car les méthodes et les attributs d’une classe sont privés par défaut. 4) Proposer une solution et expliquer le principe. La solution est : Exécution et compilation :
19 Lors de l'exécution, le programme affichera :
Principe :
Le principe se base sur mettre les variables privées en public pour laisser la fonction appeler dans la main de laisser entrer aux variables définit dans la classe pour appliquer la fonction demandés.
5 .Modifier le programme de la fonction main :
#include <iostream> using namespace std; // Définition de la classe Point class Point { private: int x; // Attribut pour l'abscisse int y; // Attribut pour l'ordonnée public:
// Constructeur par défaut qui initialise x et y à 0
Point() : x(0), y(0) {} // Méthode pour initialiser les coordonnées du point void initialise(int abs, int ord) { x = abs; // Assigne la valeur à l'abscisse y = ord; // Assigne la valeur à l'ordonnée } // Méthode pour afficher les coordonnées du point void affiche() { cout << "L'abscisse de ce point est: " << x << " et l'ordonnée est: " << y << endl;
20 } };
int main() { // Création de deux objets de type Point Point point1, point2; // Initialisation des coordonnées du premier point point1.initialise(3, 4); // Affichage des coordonnées du premier point point1.affiche(); // Initialisation des coordonnées du deuxième point point2.initialise(1, 2); // Attribution des coordonnées du deuxième point au premier point point1 = point2; // Affichage des nouvelles coordonnées du premier point après l'affectation point1.affiche(); return 0; // Fin du programme }
Exécution et compilation :
21 Lors de l'exécution, le programme affichera :
Initialisation de point1 :
• point1.initialise (3, 4) ; • point1 a x = 3 et y = 4. • Affichage : "L'abscisse de ce point est : 3 et l'ordonnée est : 4".
Initialisation de point2 :
• point2.initialise (1, 2) ; • point2 a x = 1 et y = 2. • Pas d'affichage à ce moment.
22 Affectation de point2 à point1 :
• point1 = point2 ; • point1 prend les valeurs de point2, donc x = 1 et y = 2.
Affichage des coordonnées mises à jour de point1 :
Affichage : "L'abscisse de ce point est : 1 et l'ordonnée est : 2"
Exercice 2
a) compilation :
23 b) Résultat :
c)En constructeurs :
24 TP6 : Constructeurs et destructeur Exercice1 :
25 1 -Le fichier. ccp contient les implémentations des méthodes et le fichier pour contenir les interfaces du programme 2 - Le rôle de Point () : c’est pour définir un constructeur de type par défaut Le rôle de Point () : c’est pour définir un destructeur
26 Notion de destructeur:
27 1.Testons l’exemple:
28 Commentaire:
La destruction des objets en C++ se fait dans l'ordre inverse de leur création. Comme il est illustré dans notre exemple, la création de l'objet a précède la création de l'objet b, mais la destruction se fait d'une manière inverse
29 30 Commentaire :
- Les objets créés à l'intérieur d'une fonction (comme u dans votre méthode test()) ont une portée locale à cette fonction. Ils sont détruits automatiquement lorsque vous quittez cette fonction, ce qui déclenche l'appel de leur destructeur. -Les objets créés dans main () (comme a et b) ont une portée qui s'étend jusqu'à la fin de main(), donc ils ne seront détruits qu'à ce moment-là.
31 TP 6 : Constructeurs de copie et fonctions amies : Exercice 1 :
Exécution :
32 Dans ce programme les 2 variables a et b pointent vers le même objet dont ils ont la même affectation.
Exécution :
La raison pour laquelle on a utilisé le constructeur de copie est : de créer une
nouvelle allocation mémoire afin d’avoir la capacité de modifier le b.label et a.label séparément sans influence sur le b.label puisque b.label est une copie de a.label.
33 Exercice 2 :
Exécution :
Le rôle de la fonction amie est permet à une fonction extérieure d'accéder aux membres privés de la classe. Et dans notre programme la fonction coïncide à l’extérieur de la classe peut comparer les valeurs privées d’objet Point sans nécessiter de méthodes publiques supplémentaires pour accéder aux membres x et y.
34 Exercice 3 :
Créer un programme qui additionne deux objets appartenant à deux classes A et B. Utiliser une fonction amie addition
Exécution :
35 Tp 7 : LA SURCHARGE DES OPERATEURS : Exercice 1 :
Tester le programme suivant :
Compilation :
1. La méthode utilise est la surcharge d'opérateur est externe : la fonction de surcharge est définie en dehors de la classe, et non comme une méthode membre de la classe.
Exécution :
36 2. La surcharge d'opérateur est interne, ce qui signifie que la fonction de surcharge est définie à l'intérieur de la classe, en tant que méthode membre.
Compilation :
Exécution :
3. Surcharger l’opérateur !=Compilation :
Compilation :
37 Exécution :
38 TP 8 : Héritage Exercice 1:
1- Ajouter une méthode affiche dans Pointcol void affiche ( ) { cout <<"coordonnées : ("<<x<< ","<< y << ")"<<< "couleur du point :"<<color<
2- Qu’elles sont les modifications à faire pour sur le programme principal pour afficher x, y et color
39 Apres exécution :
Pour que le programme affiche les coordonnes et la couleur du point il suffit de mettre protecetd
3- Utiliser le principe de la surdéfinition des fonctions et donner le même nom à affiche dans la classe Point et la classe Pointcol
40 Apres exécution :
L’exécution montre que la méthode affiche a permet d’afficher les attributs de la classe Pointcol.
4-Tester et commenter le programme
41 Apres exécution :
L’exécution montre que les 3 objets sont affichées leurs attributs.
42 Exercice 2 :
Ecrire un programme qui calcule les racines carrées de nombres fournis s en donnée. Il s’arrêtera lorsqu’on lui fournira la valeur 0. Il refusera les valeurs négatives. Son exécution se présentera ainsi
Apres exécution :
Ce programme demande un nombre positif à l'utilisateur pour calculer sa racine carrée,
rejette les valeurs négatives, et se termine si l'utilisateur entre zéro, en travaillant par la boucle While.
43 Conclusion : En conclusion, les exercices présentés dans ce rapport ont permis de mettre en pratique les concepts clés de la programmation en C++ et de la Programmation Orientée Objet, tels que les fonctions, la modularité, l'héritage, l'encapsulation, et la gestion des constructeurs et destructeurs. L'utilisation des structures de contrôle a également permis de structurer efficacement les programmes tout en renforçant notre compréhension des bases de la logique algorithmique. Ce travail a contribué à affiner notre maîtrise de C++ et à mieux appréhender l'importance de la POO pour développer des solutions robustes et modulaires, constituant ainsi une base solide pour des projets de développement plus avancés.
