Travaux pratiques :
Programmation Orientée objet
Réalisé par :
✓ Abba Linda
✓ Ait Said Ghizlene
Groupe :01
2020/2021
TP1
Exercice1 :
Q1 : Ecrire un programme en cpp afin de résoudre la fonction 𝑓ሺ𝑥 ሻ = 𝑥 − cosሺ𝑥 ሻ = 0 par la
méthode de dichotomie
R1 :
#include<iostream>
#include<cmath>
using namespace std;
/*---------------------------------------------------------------*/
// Déclaration des variables a,b,r et epsilon:
float a,b,r, epsilon;
/*---------------------------------------------------------------*/
// Déclaration de la fonction f(x) = x - cos(x)
float f(float x){
return (x - cos(x));
}
/*---------------------------------------------------------------*/
// fonction de dechotomie suivant l'algorithme de dichotomie :
float dichotomie(float a, float b){
float c;
while( abs(b-a) >= epsilon )
{
c = (a+b)/2;
if ( f(c)==0 )
{
r = c;
}
else
{
if ( f(a)*f(c) > 0)
{
a=c;
}
else
{
b = c;
Q2 : Testez votre programme avec 𝑎 = −1 , 𝑏 = 1 , 𝜀 = 0.01
}
}
r = c;
}
return r;
}
1
/*---------------------------------------------------------------*/
int main()
{
cout << "Donner la valeur de a:";
cin >> a;
cout << "Donner la valeur de b:";
cin >> b;
cout << "Donner la valeur epsilon:";
cin >> epsilon;
cout << "La solution est: " << dichotomie(a,b);
return 0;
}
R2 :
Exercice 2 :
Q1 : Ecrire un programme en Cpp qui peux permet de résoudre le système d’équations 5 pour
calculer 𝑖ሺ𝑡ሻ et 𝑤ሺ𝑡ሻ sur un intervalle 𝑡 ∈ ሾ0 … 5ሿ𝑠 , avec un pas de calcul de ℎ = 0.01𝑠 et les
valeurs de chaque itération sont affichées suivant le format suivant.
𝑛 𝑛∗ℎ 𝑖 𝑤
R1 :
2
#include <iostream>
#include <cstdlib>
#include <fstream>
using namespace std;
//Déclaration des Données
#define R 2.0
#define L 0.5
#define Km 0.015
#define Kb 0.015
#define Kf 0.2
#define J 0.02
#define Vapp 5.0
#define H 0.01
#define N 100
int main()
{
/*------------------------------------------------------------------------*/
//Déclaration des variables
double i = 0.0;
double w = 0.0;
/*-------------------------------------------------------------------------
*/
// Création du flux de fichier
ofstream fichier("fichier [Link]");
/*-------------------------------------------------------------------------
*/
// Test de fichier
if(fichier){
fichier<<"n"<<" , "<<"n*H"<<" , "<<"i"<<" , "<<"w"<<endl;
for(int n=0;n<=100;n++)
{
fichier<<n<<" , "<<n*H<<" , "<<i<<" , "<<w<<endl;
i = i + double(H*(-R*i - Kb*w + Vapp)/L); // equation
differrentielle du courant .
w = w + double(H*(-Kf*w + Km)/J); // equation
differentielle de la tension .
}
else{cout<<"probléme de chargement de fichier"<<endl;}
/*----------------------------------------------------------------------*/
// algorithme de calcul
[Link]();
return 0;
system("pause");
}
3
Q2 : Rediriger la sortie du programme vers un fichier texte.
R2 :
Q3 : Par la suite vous pouvez charger le fichier des résultats dans Matlab ou autre logiciel et
tracer les variations du 𝑖ሺ𝑡ሻ et 𝑤ሺ𝑡ሻ en fonction du temps.
R3 :
4
Figure 1: Courbe illustrant la variation du i(t) en fonction du temps
Figure 2 : Courbe illustrant la variation du w(t) en fonction du temps
5
TP2
Exercice 1 :
Q1 : Ecrivez une classe Compte qui représente un compte de banque.
R1 :
[Link]
#include <iostream>
#include "compte.h"
using namespace std;
bool Menu(bool compter,Compte A){
float somme;
bool renvoie = compter;
int main() {
float somme;
bool compter=true;
int choix;
cout<<"Montant de depart de C1 = ";
cin>>somme;
Compte c1(somme); //statique
cout<<"Montant de depart de C2 = ";
cin>>somme;
Compte* c2 = new Compte(somme); //dynamique
while(1) {
if (compter == true) {
cout<<endl<<endl<<"Vous etes sur le Compte C1"<<endl;
cout<<"Pour afficher votre montant appuyer sur : 1"<<endl;
cout<<"Pour ajouter de l'argent' appuyer sur : 2"<<endl;
cout<<"Pour retirer de l'argent' appuyer sur : 3"<<endl;
cout<<"Pour changer de compte appuyer sur : 4"<<endl;
cout<<"Pour quiter appuyer sur une autre touche"<<endl;
cout<<"Choix : ";
cin>>choix;
6
if (choix == 1){[Link]();}
else if (choix == 2){cout<<"Somme a ajouter = "; cin>>somme;
[Link](somme);}
else if (choix == 3){cout<<"Somme a retirer = "; cin>>somme;
[Link](somme);}
else if (choix == 4){compter = false;}
else {break;}
}
else {
cout<<endl<<endl<<"Vous etes sur le Compte C2"<<endl;
cout<<"Pour afficher votre montant appuyer sur : 1"<<endl;
cout<<"Pour ajouter de l'argent' appuyer sur : 2"<<endl;
cout<<"Pour retirer de l'argent' appuyer sur : 3"<<endl;
cout<<"Pour changer de compte appuyer sur : 4"<<endl;
cout<<"Choix : ";
cin>>choix;
if (choix == 1){c2->afficher();}
else if (choix == 2){cout<<"Somme a ajouter = ";cin>>somme;c2->deposer(somme);}
else if (choix == 3){cout<<"Somme a retirer = ";cin>>somme;c2->retirer(somme);}
else if (choix == 4){compter = true;}
else {break;}
}
}
delete c2;
return 0;
}
Compte.h
#include <iostream>
using namespace std;
class Compte{
private:
float montant;
public:
Compte(float somme);
void deposer (float somme);
void retirer (float somme);
void afficher ();
float getMontant();
~Compte();
7
[Link]
#include <iostream>
#include "compte.h"
using namespace std;
Compte::Compte(float somme=0){
if (somme>0){
montant = somme;
}
void Compte::deposer(float somme = 0){
if(somme>0){
montant += somme;
cout<<"Vous avez ajoutez: "<<somme;
cout<<"Vous avez : "<<montant;
}
}
void Compte::retirer (float somme=0){
if(somme<=montant){
montant -= somme;
cout<<"Vous avez ajoutez: "<<somme<<endl;
cout<<"Vous avez : "<<montant;
}
else {
cout<<"vous n'avez pas assez d'argent dans votre compte "<<endl;
cout<<"Vous avez : "<<montant;
}
}
void Compte::afficher (){
cout<<"Vous avez : "<<montant;
}
float Compte::getMontant(){return montant;}
Compte::~Compte(){
}
8
Figure 3 : Donner un montant pour C1 et C2
Figure 4: Choix 1 pour afficher de l'argente
Figure 5: Choix 2 pour ajouter de l'argent
9
Figure 6 : Choix 3 pour retirer de l'argent
Figure 7 : Choix 3 et le solde de compte est insuffisant
Figure 8 : Choix 4 changer de compte
10
Exercice 2 :
Q1 : Créer un nouveau type C++ permettant de manipuler des nombres complexes
R2 :
[Link]
#include <iostream>
#include<locale> //instruction pré-processeur
#include <cmath>
#include "Complexe.h"
using namespace std;
int main() {
setlocale(LC_CTYPE , "fra"); //Afin de pouvoir afficher les accents
francais.
/*------------------------------------------------------------------------*/
Complexe z1(0.0, 1.0); // Création d'un nombre complexes z1 et
l'initialiser
Complexe z2; // Création d'un nombre complexes z2
cout << "z1 = ";
[Link](); // Faire l'affichage de z1.
cout << "Donnez les valeurs de z2:";
[Link](); // Faire la lecture de z2.
cout << "\nz2 = ";
[Link](); // Pour faire une pause dans la console
taper entrer pour continuer l'execution du programme
[Link](); // Faire l'affichage de z2
[Link]();
/*------------------------------------------------------------------------*/
// Definition du complexe z3 en sommant les deux nombres complexes z1 et z2 .
Complexe z3 = z1 + z2;
cout<<"La somme de Z1 et Z2 est: ";
[Link]();
[Link]();
/*------------------------------------------------------------------------*/
// Definition du complexe z4 en soustractant les deux nombres complexes z1 et
z2 .
Complexe z4 = z1 - z2;
cout<<"La soustraction de Z1 et Z2 est: ";
[Link]();
[Link]();
/*------------------------------------------------------------------------*/
// Definition du complexe z5 en multipliant les deux nombres complexes z1 et
z2.
Complexe z5 = z1 * z2;
cout<<"La multiplication de Z1 et Z2 est: ";
[Link]();
/*------------------------------------------------------------------------*/
// Definition du complexe z6=++z2 .
[Link]();
Complexe z6 (++z2);
cout<<"L''incrementation de Z2 est: ";
[Link]();
/*------------------------------------------------------------------------*/
// Definition du complexe z7 = z1 / z2 .
[Link]();
Complexe z7 = z1 / z2;
cout<<"La division de Z1 et Z2 est: ";
[Link]();
11
/*------------------------------------------------------------------*/
// Definition du complexe z8= (z1 += z2) .
[Link]();
Complexe z8 (z1 += z2) ;
cout<<"z1 est: ";
[Link]();
/*-------------------------------------------------------------------*/
// Definition du complexe z5 en multipliant les deux nombres complexes z1
et z2 .
double x ;
[Link]();
cout<<"\ndonne un réel ";
cin>>x;
Complexe z9=z1*x;
cout<<"\nLa multiplication de Z1 par le réel est: ";
[Link]();
}
Complexe.h
#ifndef COMPLEXE_H
#define COMPLEXE_H
class Complexe
{
public:
Complexe(); // Constructeur d'objet .
Complexe(float x, float y); // Constructeur avec connaissance des
valeurs avc deux arguments .
void Lire(); // Fonction qui permet la lecture .
void Affiche(); // Fonction qui permet l'affichage .
Complexe operator+(Complexe a) ; // Surcharge de l'operateur "+", pour
l'addition des nombres complexes
Complexe operator-(Complexe a) ; // Surcharge de l'operateur "-", pour la
soustraction des nomres complexes
Complexe operator*(Complexe a) ; // Surcharge de l'operateur "*", pour la
multiplication des nombres complexes
Complexe& operator++(); // Surcharge de l'operateur "++", pour
l'incrementation des nombres complexes (auto affectation).
Complexe operator/(Complexe a) ; // Surcharge de l'operateur "/", pour la
division des nombres complexes
Complexe& operator+=(Complexe a); // Surcharge de l'operateur "+=" (auto
affectation).
Complexe operator*(double x) ; // Surcharge de l'operateur "* double ".
private:
float re, im; // les 2 parties: réelle et
imaginaire.
};
#endif
12
[Link]
#include<iostream> // les <> pour les bibliotheques standard
#include "Complexe.h" // les "" pour les fichiers personnel
#include <cmath>
using namespace std;
Complexe::Complexe() // initialisation de l'objet complexe
{
re = 0;
im = 0;
}
Complexe::Complexe(float x, float y)
{
re = x; im = y;
}
void Complexe::Lire()
{
cout << "\nDonnez la partie réel du complexe: ";
cin >> re;
cout << "Donnez la partie imaginaire du complexe: ";
cin >> im;
}
void Complexe::Affiche()
{
cout << re;
if ( im<0 )
{
cout << "-i" << 0-im;
}
else
{
cout << "+i" << im;
}
cout << endl;
}
/*-----------------------------------------------------------------------*/
// opérateur binaire "+" surcharger .
Complexe Complexe::operator+(Complexe a)
{
return Complexe(re+[Link], im+[Link]); // [Link]: la partie reel de l'objet
Complexe a
}
/*-----------------------------------------------------------------------*/
// opérateur binaire "-" surcharger en interne .
Complexe Complexe::operator-(Complexe a)
{
return Complexe([Link], [Link]); // [Link]: la partie reel de l'objet
Complexe a
}
13
/*-----------------------------------------------------------------------*/
// opérateur unaire "++" surcharger en interne .
Complexe& Complexe::operator++()
{
++re;
++im;
return *this; //retourner la valeur de l'instance actuelle en utilisant
la valeur de l'adresse
}
/*-----------------------------------------------------------------------*/
// opérateur binaire "/" surcharger en interne .
Complexe Complexe::operator/(Complexe a)
{
return Complexe(re/[Link], im/[Link]); // [Link]: la partie reel de l'objet
Complexe a
}
/*-----------------------------------------------------------------------*/
// opérateur binaire "+=" surcharger en interne .
Complexe& Complexe::operator+=(Complexe a)
{
im+=[Link];
re+=[Link];
return *this;
}
/*-----------------------------------------------------------------------*/
// opérateur binaire "* double" surcharger en interne .
Complexe Complexe::operator*(double x)
{
return Complexe(x*re, x*im);
}
Figure 9: Résultat de la compilation
14