Remarque:

Alors on trouve qu'on ne peux pas manipuler (lire et écrire) les attributs privés en dehors de
la classe par conséquence on peux surmonter le problème par l'addition de deux méthodes public
par attribut une pour lire (get) et l'autre pour écrire (set) comme suit:

#include <iostream>
#include <cmath>
using namespace std;
class Point {
public:
void iniTialise(double xi,double yi) { x_=xi; y_=yi;}
void depLace(double dx,double dy) { x_=x_+dx; y_=y_+dy;}
void afficHe() {cout<<"(x,y)= "<<x_<<","<<y_<<")"<<endl};
double diStance(Point autrPoint) {
double dx=x_-autrPoint.x_; double dy=y_-autrPoint.y_;
return sqrt(dx*dx+dy*dy); }
double moDule() {
return sqrt(x_*x_+y_*y_); }
double getX() { return x_ ;} void setX(double sx) {x_ =sx;}
double getY() { return y_ ;} void setY(double sy) {y_ =sy;}
private: double x_ ,y_ ;
};

//validation de la classe point:

int main() {
Point P1,P2; double Xi,Yi;
cout<<"premier point xi= " <<endl; cin>>Xi; P1.setX(Xi); cout<<"P1(x)="<<P1.getX()<<endl;
cout<<" premier point yi= " <<endl; cin>>Yi; P1.setY(Yi); cout<<"P1(y)="<<P1.getY()<<endl;
cout<<"deuxième point xi= " <<endl; cin>>Xi; P2.setX(Xi);cout<<"P2(x)="<<P2.getX()<<endl;
cout<<" deuxième point yi= " <<endl; cin>>Yi; P2.setY(Yi);cout<<"P2(y)="<<P2.getY()<<endl;

return 0; }

le constructeur:
c'est une méthode spéciale non typée qui porte le même nom que la classe; son rôle est de
déterminer la manière de création des objets et l'initialisation de ces attributs systématiquement.
une classe peut avoir plusieurs constructeurs (plusieurs façons de création d'objet).
si il y a pas de constructeur explicite le compilateur génère un par défaut sans effet.
l'utilisation des constructeur donne une souplesse à la classe et éviter la conception des méthodes
auxiliaires d'initialisation
plusieurs constructeurs peuvent être implémenter mais de paramètres différents
application: refaire la classe Point en introduisant cette notion.
#include <iostream>
#include <cmath>
using namespace std;
class Point {
public:
Point( ) {x_=0; y_=0;}
Point(double c){x_=c; y_=0;}
Point(double a, double b) {x_=a; y_=b;}

void depLace(double dx,double dy) { x_=x_+dx; y_=y_+dy;}

void afficHe() {cout<<"(x,y)= "<<x_<<","<<y_<<")"<<endl};
double diStance(Point autrPoint) {
double dx=x_-autrPoint.x_; double dy=y_-autrPoint.y_;
return sqrt(dx*dx+dy*dy); }
double moDule() {
return sqrt(x_*x_+y_*y_); }
double getX() { return x_ ;} void setX(double sx) {x_ =sx;}
double getY() { return y_ ;} void setY(double sy) {y_ =sy;}

private: double x_ ,y_ ;

};

//validation de la classe point:

int main() {
Point P1() , P2(2.5) , P3(1.5,3.5); //création et initialisation de trois objets différemment.
cout<<"x du point P1 est: " <<P1.getX()<<endl;

cout<<"le module de P1 est: " <<P1.module()<<endl;

cout<<"le module de P2 est: " <<P2.module()<<endl;
cout<<"le module de P3 est: " <<P3.module()<<endl;
cout<<"la distance entre P1 et P2 est: " <<P1.diStance(P2)<<endl;
cout<<"la distance entre P2 et P3 est: " <<P2.diStance(P3)<<endl;
cout<<"la distance entre P3 et P1 est: " <<P3.diStance(P1)<<endl;

P1.setX(5);

return 0; }

redéfinition de fonction (surcharge ou polymorphisme) et l'opérateur this:

c'est la possibilité d'avoir plusieurs méthodes de même nom mais de paramètre différentes tandis
que l'opérateur this pointe les attributs de l'objet courant explicitement.
exemple:

double diStance(Point dp) {

double dx= x_-dp.x_; double dy=y_-dp.y_;
return sqrt(dx*dx+dy*dy); }

/*double diStance(Point dp) {

double dx=this--> x_-dp.x_; double dy= this--> y_-dp.y_;
return sqrt(dx*dx+dy*dy); }*/
surcharge ou polymorphisme:

double diStance(Point P1, Point P2) {

double dx=P1.x_-P2.x_; double dy=P1.y_-P2.y_;
return sqrt(dx*dx+dy*dy); }

compilation séparée:
c'est la séparation de la classe en deux fichiers distincts le premier (classe.h) porte les noms des
membres et le deuxième (classe.cpp) porte les corps des méthodes (code c++).
lors de l'exploitation de la classe on introduire uniquement le fichier entête (classe.h).

//***********************************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 p1, Point p2);
double moDule();

virtual ~Point();
protected:
private:
double x,y;
};

#endif // POINT_H

//***********************************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; // int dx=this->x-autrPoint.x;
double dy=this->y-autrPoint.y; // int dy=this->y-autrPoint.y;
return sqrt(dx*dx+dy*dy);
}
double Point::diStance(Point p1, Point p2)
{
double dx=p2.x-p1.x;
double dy=p2.y-p1.y;
return sqrt(dx*dx+dy*dy);
}

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

Point::~Point(){ }

//**************************le projet testPoint.cpp************************

#include <iostream>
#include <cmath>
#include "point.h"

int main() {
Point P1() , P2(2.5) , P3(1.5,3.5); //création et initialisation de trois objets différemment.
cout<<"x du point P1 est: " <<P1.getX()<<endl;

cout<<"le module de P1 est: " <<P1.module()<<endl;

cout<<"le module de P2 est: " <<P2.module()<<endl;
cout<<"le module de P3 est: " <<P3.module()<<endl;
cout<<"la distance entre P1 et P2 est: " <<P1.diStance(P2)<<endl;
cout<<"la distance entre P2 et P3 est: " <<P2.diStance(P3)<<endl;
cout<<"la distance entre P3 et P1 est: " <<P3.diStance(P1)<<endl;

P1.setX(5);

return 0; }