22/11/2022

Membre Constant ou Statique et

Opérateur de Conversion

A.SOUHAR

Donnée membre constante

#include <iostream> void Point::afficher()
using namespace std; {
cout<<"[("<<x<<","<<y<<")";
class Point{ cout<<";numéro:"<<num<<"]";
cout<<endl;
int x,y; }
const int num; int main()
{
public: Point p1(2,3,1),p2(2,3,2);
p1.afficher();
Point(int a,int b,int n):num(n) p2.afficher();
{x=a; y=b;}
void afficher(); return 0;
}; }

1
 22/11/2022

Méthode constante
int main()
#include <iostream> { Point p1(2,2), p2(1,1);
#include <math.h>
cout<<"\np1 = ";
using namespace std;
class Point{ p1.afficher();
int x,y;
public: p1.deplacer(-2,-2);
Point(int a,int b) cout<<"\np1 = ";
{x=a; y=b;} p1.afficher();
void afficher()const //méthode de consultation
{cout<<"("<<x<<","<<y<<")";} cout <<"\nla distance entre ";
void deplacer(int dx,int dy) p1.afficher();
{x+=dx; y+=dy; } //méthode de modification cout <<" et ";
float distance(Point autrePoint)const;
p2.afficher();
};
float Point::distance(Point autrePoint) const{ cout<<" est: ";
int dx = x - autrePoint.x; cout<<p1.distance(p2)<<endl;
int dy = y - autrePoint.y;
return sqrt(dx * dx + dy * dy); return 0;
} }

Méthode constante et non constante

#include <iostream>
using namespace std; int main()
{
class Point{ Point P(1,1);
int x,y; cout<<"P=";
public: P.afficher();
Point(int a,int b) cout<<endl;
{x=a; y=b;} cout<<"P.x="<<P.X()<<endl;
int X() const{return x;} cout<<"P.y="<<P.Y()<<endl;
int Y() const{return y;} P.X()=3; P.Y()=4;
int& X() {return x;} cout<<"P=";
int& Y(){return y;} P.afficher();
void afficher(){ cout<<endl;
cout<<"("<<x<<","<<y<<")";}
}; return 0;
}

2
 22/11/2022

Méthode constante et objet constant

#include <iostream>
using namespace std;
class Point{
int x,y;
public:
Point(int a,int b)
{x=a; y=b;}
int X() const{return x;}
int Y() const{return y;}
int& X() {return x;}
int& Y(){return y;}
void afficher() const {
cout<<"("<<x<<","<<y<<")";}
};
int main()
{
const Point Origine(0,0);
cout<<"Origine=";
Origine.afficher();
cout<<endl;
cout<<"Origine.x= ";
cout<<Origine.X()<<endl;
cout<<"Origine.y= ";
cout<<Origine.Y()<<endl;
//Origine.X()=3; pb
//Origine.Y()=4; pb
cout<<endl;
return 0;
}

Champs membre statique

#include <iostream> int Point::nbPoints=0;
using namespace std;
int main()
class Point{ {
int x, y; Point p1;
public: cout<<"Num:"<<p1.nbPoints<<" ";
static int nbPoints; p1.afficher(); cout <<endl;
Point(int abs= 0, int ord= 0){ Point p2(3,4);
x = abs; y = ord; cout<<"Num:"<<p2.nbPoints<<" ";
nbPoints++; } p2.afficher(); cout <<endl;
void afficher() { cout<<"\nNum:"<<Point::nbPoints;
cout<<"("<<x<<","<<y<<")";} return 0;
}

};

3
 22/11/2022

Champs membre statique

#include <iostream> int Point::nbPoints=0;
using namespace std;
int main()
class Point{ {
int x, y; Point p1;
static int nbPoints; cout<<"Num:"<<p1.nbPts()<<" ";
public: p1.afficher(); cout <<endl;
Point p2(3,4);
Point(int abs= 0, int ord= 0){ cout<<"Num:"<<p2.nbPts()<<" ";
x = abs; y = ord; p2.afficher();
nbPoints++; } return 0;
void afficher() { }
cout<<"("<<x<<","<<y<<")";}

int nbPts(){return nbPoints;}

};

Méthode statique
#include <iostream> int Point::nbPoints=0;
using namespace std;
int main()
class Point{ {
int x, y; Point p1;
static int nbPoints; cout<<"Num:"<<p1.nbPts()<<" ";
public: p1.afficher(); cout <<endl;
Point p2(3,4);
Point(int abs= 0, int ord= 0){ cout<<"Num:"<<p2.nbPts()<<" ";
x = abs; y = ord; p2.afficher(); cout <<endl;
nbPoints++; } cout<<"\nNum:"<<Point::nbPts();
void afficher() { return 0;
cout<<"("<<x<<","<<y<<")";} }

static int nbPts(){return nbPoints;}

};

4
 22/11/2022

Méthode statique
#include <iostream> int Point::nbPoints=0;
using namespace std; int main()
class Point{ {
int x; Point *t=new Point[3];
int y; cout<<"\nNum:"<<t->nbPts();
static int nbPoints; //Num :3
public: delete[]t;
Point(int abs= 0, int ord= 0){ cout<<"\nNum:"<<Point::nbPts();
x = abs; y = ord; //Num :0
nbPoints++;} Point p1(10,15);
~Point() cout<<"\nNum:"<<p1.nbPts()<<" ";
{nbPoints--;} //(10,15) Num :1
void afficher() p1.afficher();
{cout <<"("<<x <<","; cout<<"\nNum:"<<Point::nbPts();
cout<<y<<")"<<endl;} //Num :1
static int nbPts(){return nbPoints;} return 0;
}; }

Opérateur de conversion implicite

#include <iostream> Point operator+(const Point& M, const
using namespace std; Point&N)
class Point{ { Point S(M.x+N.x,M.y+N.y);
int x,y; return S;
public: }

Point(int a=0,int b=0) int main()

{x=a; y=b;} {
Point p1(2,3),p2;
void afficher(); p2.afficher();cout<<endl; //(0,0)
p2=p1;
friend Point operator+(const p2.afficher();cout<<endl; //(2,3)
Point&,const Point&); p2=4;
}; p2.afficher();cout<<endl; //(4,0)
p2=p1+4;
void Point::afficher() p2.afficher();cout<<endl; //(6,3)
{cout<<"("<<x<<","<<y<<")"; } return 0;
}

5
 22/11/2022

Opérateur de conversion explicite

#include <iostream> Point operator+(const Point& M, const
using namespace std; Point&N)
{ Point S(M.x+N.x,M.y+N.y);
class Point{ return S;
int x,y; }
public:
explicit Point(int a=0,int b=0) int main()
{x=a; y=b;} {
void afficher(); Point p1(2,3),p2;
p2.afficher();cout<<endl; //(0,0)
friend Point operator+(const p2=p1;
Point&,const Point&); p2.afficher();cout<<endl; //(2,3)
}; p2=Point(4,0); //p2=4; pb
p2.afficher();cout<<endl; //(4,0)
Point::operator int()const p2=p1+Point(4,0); //p2=p1+4;pb
{ p2.afficher();cout<<endl; //(6,3)
return x; return 0;
} }

Opérateur de conversion inverse

#include <iostream> int main()
using namespace std; {
Point p1(2,3),p2(5,6);
class Point{ cout<<"p1=";
int x,y; p1.afficher();cout<<endl;
public: int x1=(int)p1;
Point(int a=0,int b=0) cout <<"x1="<<x1<<endl; //x1=2
{x=a; y=b;} cout<<"p2=";
void afficher() p2.afficher();cout<<endl;
{cout<<"("<<x<<","<<y<<")";} int x2=(int)p2;
cout<<"x2="<<x2; //x2=5
operator int()const; return 0;
}; }

Point::operator int()const
{
return x;
}