projet de synthèse (version pour faire le test Tp s'il y a lieu)

créer une classe Triangle et essayer de la valider dans un projet tesTriangle; la classe en question basée
principalement sur la classe point comporte les membres suivants:
six attributs privés, trois de type Point (exemple P1,P2,P3) désignant les sommets du triangle et trois de type double
pour évaluer les distances (exemple L1,L2,L3).
un constructeur Triangle() pour définir systématiquement les objets Triangle; un objet Triangle est défini par les trois
points des sommets et les distances entre eux.
une méthode typée (doubel) calPerimetre() retournant le périmètre du triangle.
une méthode typée (string) isocEl() retournant le type du triangle "isocel" ou "non isocel";
une méthode typée (doubel) getL1() pour dégager la distance entre P1 et P2.
une méthode typée (doubel) getL3()pour dégager la distance entre P3 et P1.
Nb: essayer de créer les objets P1,P2,P3 différemment (vous avez trois constructeurs de la classe Point)
un triangle est isocel si L1=L2=L3.

Solution proposée:

/****************************le fichier triangel.h*******************************/

#ifndef TRIANGLE_H
#define TRIANGLE_H
#include <string>
using namespace std;
class Triangle
{
public:
Triangle(); // le constructeur
virtual ~Triangle(); // le destructeur par défaut
double calPerimetre();
string isocEl();
double getL1();
double getL2();
double getL3();
protected:
private:
Point P1,P2,P3;
double L1,L2,L3;
};

#endif // TRIANGLE_H
/****************************le fichier triangel.cpp*******************************/

#include <iostream>
#include <cmath>
#include "point.h"
#include "triangle.h"
using namespace std;

Triangle::Triangle()
{
//Point P1(1,1),P2(2),P3(); // une manière de création des objets
P1=Point(1,1); P2=Point(2); P3=Point(); // essayer de saisir les coordonnés x et y par clavier (en utilisant cout et cin
L1=P1.diStance(P2); L2=P2.diStance(P3); L3=P3.diStance(P1);
}
double Triangle::calPerimetre()
{
return L1+L2+L3;
}
double Triangle::getL1(){ return L1;}
double Triangle::getL2(){ return L2;}
double Triangle::getL3(){ return L3;}

string Triangle::isocEl()
{
if (L1==L2 && L2==L3) return "isocel";
else return "nonisocel";
}

Triangle::~Triangle(){ /*destructeur*/}

/***************************************le fichier point.h**********************************/

#ifndef POINT_H
#define POINT_H
class Point
{
public:
Point(); Point(double); Point(double,double);
double getX(); double getY();
void setX(double); void setY(double);
void depLace(double,double);
void afficHe(Point);
double diStance(Point autrPoint);
double diStance(Point pi, Point pf);
double moDule();
virtual ~Point();
protected:
private:
double x,y;
};
/***************************************le fichier point.cpp********************************/
#include <iostream>
#include <cmath>
#include "point.h"
using namespace std;

Point::Point(){ x=0;y=0; }
Point::Point(double a){ x=a;y=0; }
Point::Point(double a,double b){ x=a;y=b; }
double Point::getX(){ return x;}
double Point::getY(){ return y;}
void Point::setX(double a){x=a;}
void Point::setY(double b){x=b;}
void Point::depLace(double dx,double dy){ x=x+dx; y=y+dy;}
void Point::afficHe(Point p1)
{
cout<<"p1(x,y)= ("<<p1.x<<","<<p1.y<<")"<<endl;
}
double Point::diStance(Point autrPoint)
{
double dx=this->x-autrPoint.x; ;
double dy=this->y-autrPoint.y;
return sqrt(dx*dx+dy*dy);
}
double Point::diStance(Point pi, Point pf)
{
double dx=pf.x-pi.x; double dy=pf.y-pi.y;
return sqrt(dx*dx+dy*dy);
}

double Point::moDule() { return sqrt(x*x+y*y); }

Point::~Point(){/*destructeur*/ }

//validation de la classe Triangle dans un projet tesTriangle.

/*************************************le fichier projet tesTriangle.cpp**********************/

#include <iostream>
#include <cmath>
#include <string>
#include "point.h"
#include "triangle.h"
using namespace std;
int main()
{
Triangle t;// création d'un objet Triangle
t.calPerimetre();
cout<<"le triangle t est :"<<t.isocEl()<<endl;
cout<<t.getL1()<<endl; cout<<t.getL2()<<endl; cout<<t.getL3()<<endl;

return 0; }