Compte Rendu
TP
C++ et programmation
orientée objet
Hiba ELBouaichi
GEE1
Contents:
Tableau de matière: ………………………………………………………………………….…..…1
Transmission par valeur:.......................................................................................................2
Transmission par adresse:....................................................................................................3
Transmission par référence :.................................................................................................4
TP I. Les entrées_sorties : ....................................................................................................5
Exercice 1: somme et produit................................................................................................5
Les instructions de contrôles en C+
+ :.................................................................................6
Exercice 1 :solution d’equation............................................................................................6
TP 4 .Classes et Objets : .......................................................................................................
Exercice 1 : .............................................................................................................................7
Notion de constructeur : ……..………….…………………………………………….…………..7
Constructeur de copie ……………………….……………………………………………..…….12
1|Page
Transmission par valeur:
#include <iostream>
using namespace std;
void echange(int a, int b)
{
int c;
cout << "debut echange:" <<a<<" "<< b << endl;
c=a;
a=b;
b=c;
cout<<"fin echange:"<<a<<" "<<b<<endl;
}
int main()
{
int n=10,p=20;
cout << "avant appel:" <<n<<" "<<p<< endl;
echange(n,p);
cout << "apres appel:" <<n<<" "<<p<< endl;
}
Quand un paramètre est transmis à une fonction, sa valeur est copiée dans une
variable locale. Cette variable est ensuite utilisée pour effectuer les calculs dans la
fonction appelée
2|Page
Transmission par adresse:
#include<iostream>
using namespace std;
void echange (int *a, int *b)
{ int c:
cout << "debut echange"<<*a<<" "<< <<*b<< endl;
c=*a:
* a = *b;
* b = c;
cout << "fin echange: " << *a <<" "<<*b << endl;
}
main ()
{
int n = 10 ,p = 20;
cout << "avant appel:"<<n<<" "<< p << endl;
echange (&n, &p);
cout << "apres appel"<<n<<""<< p << endl;
}
En C, la transmission par adresse utilise des pointeurs pour permettre à la
fonction d'accéder directement à l'adresse mémoire de l'argument.
3|Page
Transmission par référence :
#include<iostream>
using namespace std;
void echange (int& a,int& b)
{
int c;
cout << "debut echange"<<a<<""<< b << endl;
c = a;
a = b;
b = c;
cout << "fin echange: " << a << " " <<b<<endl;
}
main ()
{
int n = 10 ,p = 20 ;
cout << "avant appel: " << n << " " << p << endl;
echange (n, p);
cout << "apres appel: " << n << " " << p << endl;
La transmission d'un objet par référence permet à la fonction de le modifier
directement, sans en créer une copie dans son propre espace mémoire.
4|Page
Les entrées et sorties :
Exercice 1 : « Somme et Produit»
5|Page
Les instructions de contrôles en C++ :
Exercice 1 : « Résolution d’équation»
#include<iostream>
#include<Cmath>
using namespace std;
int main()
{
float a,b,c,delta,x1,x2;
cout << "Entrer les a,b et c "<<endl;
cin>>a>>b>>c;
delta=b*b_4*a*c ;
if(delta>0)
{
X1=(-b+sqrt(delta))/2*a ;
X2=(-b-sqrt(delta))/2*a ;
cout << "Les solutions sont: " << x1,x2 << endl;
}
Return 0 ;
}
6|Page
TP4 : Classes et Objets :
Notion de constructeur :
Exercice 1 :
1)
2)Compilation :
Le problème de ce code est que les méthodes initialise(int, …) et affiche() sont
déclarées comme privées dans la classe Point, ce qui empêche leur appel direct
depuis main().
7|Page
8|Page
Apres modification :
Compilation :
Le problème principal était une tentative d'affectation entre objets alors que les
membres étaient private. La solution consiste à ajouter une méthode spécifique pour
copier les valeurs d’un point à un autre.
9|Page
Problème initial
Dans le premier code, les attributs x et y étaient privés (private) par défaut. Cela
empêche main() d’accéder directement à ces valeurs, et rend aussi l’affectation
point1 = point2; invalide car la classe ne fournit pas d’opérateur d’affectation
personnalisé.
Pourquoi public est important ici ?
En mettant les méthodes en public, on permet :
D'initialiser les valeurs via [Link](3,4);.
D'afficher les valeurs via [Link]();.
De copier un point dans un autre via [Link](point2);.
Conclusion : public est essentiel pour exposer des fonctionnalités contrôlées tout en
protégeant les données internes de la classe.
10 | P a g e
TP5 :Constructeurs et Destructeurs :
Exercice 1 :
Création d’une Classe Point :
Fichier head
Fichier source
11 | P a g e
1. Explication des fichiers générés par Code::Blocks
Quand on crée une classe avec Code::Blocks, deux fichiers sont automatiquement générés :
Point.h (fichier d’en-tête) : il contient la déclaration de la classe.
[Link] (fichier source) : il regroupe l’implémentation des méthodes de la classe,
sans inclure la fonction main().
👉 Cette séparation améliore l’organisation du code et simplifie sa maintenance.
Classe :
12 | P a g e
Constructeur de copie :
13 | P a g e
Programme A :
Pourquoi le constructeur de copie intervient ici ?
Lorsque l’on écrit PointNomme *b = a;, on ne copie pas réellement l’objet,
mais uniquement l’adresse mémoire de l’objet pointé par a. Ainsi, a et b
font référence à la même zone mémoire.
Dans ce cas, le constructeur de copie par défaut de C++ copie simplement l'adresse du
pointeur label au lieu de dupliquer son contenu.
14 | P a g e
Programme B :
Dans le programme B, un constructeur de copie explicite a été ajouté. Ainsi,
lorsqu’un objet PointNomme est copié, une nouvelle zone mémoire est attribuée
pour le champ label, et le contenu de la chaîne est dupliqué au lieu de
simplement copier l’adresse du pointeur.
Différence avec le programme précédent
Dans le programme sans constructeur de copie explicite, b et a partageaient la
même adresse mémoire pour label. Ainsi, toute modification de label sur l’un
impactait également l’autre.
15 | P a g e
16 | P a g e
