Série TD C++ 

:
TD 1 :
Exercice 4 : classe Point :
#include <iostream>
using namespace std ;
/* ------------ Déclaration de la classe point ------------- */
class point {
private :
int x;
int y;
public :
point (int,int);
int getx ();
int gety ();
void setx (int v);
void sety (int k);
void deplace (int, int) ;
void affiche () ;
};
point::point (int abs, int ord) {
x=abs;
y= ord;
}
int point::getx(){
return x ;
}
int point::gety(){
 return y ;
}
void point::setx(int v){
x=v;
}
void point::sety(int k){
y=k;
}
void point::deplace(int dx,int dy){
x=x+dx;
y=y+dy;
}
void point::affiche(){
cout << "Je suis en " << x << " " << y << "\n" ;
}
main(){
point a(5,2);
a.affiche();
a.deplace(6,9);
a.affiche ();
a.setx(2);
cout<<a.getx();
}
Exercice 5 : classe Cercle :
#include <iostream>
#include <cmath> // Ajouter cette bibliothèque pour utiliser la fonction sqrt()
using namespace std;

class cercle {
private :
int r;
int x;
int y;
public :
cercle(int, int, int);
~cercle ();
int getx();
int gety();
void setx(int f);
void sety(int h);
void setcentre(double,double);
double surface(); // supprimer le paramètre int ici
bool estInterieur(double, double) const; // modifier le type des paramètres
int en double ici
};

cercle::cercle(int a,int b,int k){

x=a;
y=b;
r=k;
}

cercle::~cercle(){
}

int cercle::getx(){
return x;
}

int cercle::gety(){
return y;
}

void cercle::setx(int f){

x=f;
}

void cercle::sety(int h){

y=h;
}

void cercle::setcentre(double dx,double dy){

x=dx;
y=dy;
}

double cercle::surface(){ // supprimer le paramètre int ici

return 3.14 * r * r;
}
bool cercle::estInterieur(double x1, double y1) const { // modifier le type des
paramètres int en double ici
double distance = sqrt(pow(x1 - x, 2) + pow(y1 - y, 2));
return distance <= r;//Elle compare ensuite cette distance au rayon du cercle
}

int main(int argc, char** argv) {

cercle c1(0, 0, 5); // créer un cercle de rayon 5 et de centre (0,0)
cercle c2(2, 2, 3); // créer un cercle de rayon 3 et de centre (2,2)

// Tester la méthode surface

cout << "Surface du cercle c1 : " << c1.surface() << endl;
cout << "Surface du cercle c2 : " << c2.surface() << endl;

// Tester la méthode estInterieur

double x1 = 1.0;
double y1 = 2.0;
if (c1.estInterieur(x1, y1)) { // modifier le nom des variables pour
correspondre à la signature de la méthode
cout << "(" << x1 << "," << y1 << ") est dans le cercle c1." << endl;
} else {
cout << "(" << x1 << "," << y1 << ") n'est pas dans le cercle c1." << endl;
}
return 0;
}
Exercice 6 : classe Point3D
#include <iostream>
#include <cmath>
using namespace std;

class Point {
private :
float x;
float y;
float z;
public :
Point(float a, float b, float k);
~Point();
void affiche();
bool compare(const Point& p2) const; // fonction compare entre deux point
on utilise objet
};

Point::Point(float a, float b, float k){// constructeur

x = a;
y = b;
z = k;
}

Point::~Point(){
}

void Point::affiche(){
cout << "Les coordonnees sont : (" << x << ", " << y << ", " << z << ")" << endl;
}

bool Point::compare(const Point& p2) const{

return x == p2.x && y == p2.y && z == p2.z;
};
int main(){
Point p1(1, 2, 3);
Point p2(1, 2, 4);
Point p3(1, 2, 3);

p1.affiche();
p2.affiche();
p3.affiche();

if(p1.compare(p2)){
cout << "p1 et p2 ont les memes coordonnees." << endl;
}
else{
cout << "p1 et p2 n'ont pas les memes coordonnees." << endl;
}

if(p1.compare(p3)){
cout << "p1 et p3 ont les memes coordonnees." << endl;
}
else{
cout << "p1 et p3 n'ont pas les memes coordonnees." << endl;
}
 return 0;
}
Exercice 7 : classe Rectangle :
#include <iostream>
#include <cmath>

using namespace std;

class Point {

public:
float x;

float y;
Point(float a = 0, float b = 0){ // constructeur par défaut avec des valeurs par défaut

x = a;
y = b;

}
};

class Rectangle {

public:
Point p;

float longueur;
float largeur;

public:
Rectangle(); // constructeur par défaut

Rectangle(Point p); // constructeur avec la position p

Rectangle(float longueur, float largeur); // constructeur avec les dimensions

Rectangle(Point p, float longueur, float largeur); // constructeur avec tous les attributs
float perimetre() const;

float surface() const;

 float diagonale() const;
void doublerDim();

void deplacer(float a, float b);

};

Rectangle::Rectangle(){

longueur=0;

largeur=0;

Rectangle::Rectangle(Point k){
p = k;

Rectangle::Rectangle(float r, float l){

this->longueur = r;

this->largeur = l;
}

Rectangle::Rectangle(Point k, float r, float l){

p = k;
longueur = r;

largeur = l;
}

float Rectangle::perimetre() const{

return 2 * (longueur + largeur);

}
float Rectangle::surface() const{

return longueur * largeur;

}

float Rectangle::diagonale() const{

return sqrt(pow(longueur, 2) + pow(largeur, 2));

}

void Rectangle::doublerDim(){

longueur *= 2;
largeur *= 2;

void Rectangle::deplacer(float a, float b){

p.x += a;

p.y += b;
}

int main(){

Rectangle r1;
cout << "Rectangle r1 : longueur = " << r1.longueur << ", largeur = " << r1.largeur << ", p = (" <<
r1.p.x << ", " << r1.p.y << ")" << endl;

Rectangle r2(Point(2, 3));

cout << "Rectangle r2 : longueur = " << r2.longueur << ", largeur = " << r2.largeur << ", p = (" <<
r2.p.x << ", " << r2.p.y << ")" << endl;

Rectangle r3(4, 5);

cout << "Rectangle r3 : longueur = " << r3.longueur << ", largeur = " << r3.largeur << ", p = (" <<
r3.p.x << ", " << r3.p.y << ")" << endl;

Rectangle r4(Point(1, 1), 3, 4);

 cout << "Rectangle r4 : longueur = " << r4.longueur << ", largeur = " << r4.largeur << ", p = (" <<
r4.p.x << ", " << r4.p.y << ")" << endl;

cout << "Le périmètre de r4 est : " << r4.perimetre() << endl;

cout << "La surface de r4 est : " << r4.surface() << endl;
return 0 ;