Le programme présenté dans cette page est un petit projet C++ que j'ai réalisé dans le cadre de mes études afin de mettre en pratique les principaux concepts de la programmation orientée objet. Son objectif consiste à manipuler des points géométriques et des polygones, puis à effectuer différents calculs, notamment celui du périmètre d'une figure quelconque. Bien que relativement modeste, cet exemple illustre plusieurs notions fondamentales du langage C++, telles que la séparation entre les fichiers d'en-tête et les fichiers d'implémentation, l'utilisation des constructeurs, la surcharge d'opérateurs, l'allocation dynamique de mémoire ainsi que la conception de classes réutilisables. Il constitue ainsi un excellent exercice pour comprendre la structure d'un projet C++ organisé selon les bonnes pratiques.
Le projet est réparti en cinq fichiers distincts afin de reproduire l'organisation d'une véritable bibliothèque logicielle. Les deux fichiers d'entête, CPoint.H et CPolygone.H, déclarent respectivement les classes, leurs attributs, leurs méthodes et les opérateurs disponibles. Les deux fichiers d'implémentation, CPoint.CPP et CPolygone.CPP, contiennent le code source complet des méthodes membres, des constructeurs ainsi que des différentes opérations géométriques. Enfin, le fichier TestExer.CPP constitue le programme principal chargé de créer les objets, de demander les coordonnées des sommets à l'utilisateur, de calculer le périmètre du polygone, puis d'effectuer différentes manipulations afin de démontrer le fonctionnement des classes.
Au-delà du simple calcul géométrique, ce projet illustre également plusieurs mécanismes importants du C++ classique. On y retrouve notamment la surcharge des opérateurs arithmétiques et de comparaison, la copie d'objets, la gestion de tableaux dynamiques d'objets, l'encapsulation des données, les méthodes d'accès ainsi que les opérations de translation d'un ensemble de points. Bien qu'il ait été développé dans un contexte pédagogique, cet exemple montre comment structurer une petite bibliothèque orientée objet en séparant clairement les interfaces de leur implémentation, tout en conservant un code relativement simple à comprendre et à faire évoluer :
// CPoint.H
// •·········································································•
// · ·
// · C P o i n t ·
// · Définition ·
// · ·
// · Programmeur: Sylvain Maltais ·
// · Date: 1999-02-04 ·
// · ·
// · Description ·
// · ___________ ·
// · ·
// · Ce fichier contient l'entêtes du problèmes de calcul de la distance ·
// · à l'origine selon la formule de Pythagore. ·
// · ·
// •·········································································•
#ifndef __CPOINT
#define __CPOINT
#include <stdio.h>
#include <conio.h>
#include <math.h>
#define FALSE 0 // Valeur de la constante booléenne FAUX.
#define TRUE !FALSE // Valeur de la constante booléenne VRAI.
typedef unsigned char Boolean;
class CPoint {
// Cette objet calcul la distance d'un point par rapport à l'origine.
//_________________________________________________________________________
private:
//_________________________________________________________________________
double m_X, m_Y;
//_________________________________________________________________________
public:
//_________________________________________________________________________
CPoint ( void ); // Initialise l'objet «CPoint» afin de permettre
// l'utilisation des fonctions de l'objet.
CPoint ( double x, double y );
// Fixe la nouvelle position de la coordonnée.
void fixeposition ( double nouveaux, double nouveauy );
// Demande la coordonnée horizontal de la position actuel à partir
// duquel sont effectuées les calculs.
double demandex ( void );
// Demande la coordonnée vertical de la position actuel à partir
// duquel sont effectuées les calculs.
double demandey ( void );
// Permet l'affichage à une position texte d'écran la position actuel
// du couple.
void afficherxy ( char x, char y );
// Applique un déphasage à une coordonnée sans changer la coordonnée
// d'origine, mais seulement le couple.
void dephasage ( double nouveaux, double nouveauy );
double distorigine ( void ); // Affiche la distance à partir de l'origine.
// Opérateur
double operator * ( CPoint point ); // Produit scalaire d'un point.
CPoint operator + ( CPoint point ); // Dephasage à partir d'un point existant
// Oriente les points dans le 3eme cadran où les deux coordonnées sont négatives.
CPoint operator ! ( void );
// Cette opérateur permet d'indiquer si l'opérateur est inférieur
// à celui comparer.
Boolean operator > ( CPoint point );
// Cette opérateur permet d'indiquer si l'opérateur est supérieur
// à celui comparer.
Boolean operator < ( CPoint point );
// Cette opérateur permet d'indiquer si l'opérateur est inférieur ou égal
// à celui comparer.
Boolean operator >= ( CPoint point );
// Cette opérateur permet d'indiquer si l'opérateur est supérieur ou égal
// à celui comparer.
Boolean operator <= ( CPoint point );
// Cette opérateur permet d'indiquer si l'opérateur est égal
// à celui comparer.
Boolean operator == ( CPoint point );
//_________________________________________________________________________
};
#endif
Ensuite le fichier de code source «CPoint.CPP»:
// CPoint.CPP
// · C P o i n t ·
// · (Code Source) ·
// · ·
// · Programmeur: Sylvain Maltais ·
// · Date: 1999-02-04 ·
// · ·
// · Description ·
// · ___________ ·
// · ·
// · Ce fichier contient les sources du problèmes de calcul de la distance ·
// · à l'origine ainsi qu'entre deux couples selon la formule de Pythagore. ·
#include <stdio.h>
#include <conio.h>
#include <math.h>
#include "CPOINT.H"
// •·····································································•
// · Constructeur initialise ·
// •·····································································•
//
//
// Description
// ___________
//
// Cette routine initialise l'objet «CPoint» afin de permettre
// l'utilisation des fonctions de l'objet.
CPoint::CPoint( void ) {
m_X = 0, m_Y = 0;
};
// •·····································································•
// · Constructeur initialise ·
// •·····································································•
//
//
// Description
// ___________
//
// Cette routine initialise l'objet «CPoint» afin de permettre
// l'utilisation des fonctions de l'objet avec un point utilisateur.
CPoint::CPoint( double x, double y ) {
m_X = x, m_Y = y;
};
// •·····································································•
// · Opérateur * ·
// •·····································································•
//
//
// Description
// ___________
//
// Cette opértaeur produit scalaire d'un point.
double CPoint::operator * ( CPoint point ) {
return point.m_X * m_X + point.m_Y * m_Y;
};
// •·····································································•
// · Opérateur + ·
// •·····································································•
//
//
// Description
// ___________
//
// Cette opérateur effectue un déphasage à partir d'un point existant.
CPoint CPoint::operator + ( CPoint point ) {
CPoint retour;
retour.m_X = point.m_X + m_X, retour.m_Y = point.m_Y + m_Y;
return retour;
};
// •·····································································•
// · Opérateur ! ·
// •·····································································•
//
//
// Description
// ___________
//
// Oriente les points dans le 3eme cadran où les
// deux coordonnées sont négatives.
CPoint CPoint::operator ! ( void ) {
CPoint retour;
retour.m_X = this -> m_X * -1, retour.m_Y = this -> m_Y * -1;
return retour;
};
// •·····································································•
// · Opérateur > ·
// •·····································································•
//
//
// Description
// ___________
//
// Cette opérateur permet d'indiquer si l'opérateur est inférieur
// à celui comparer.
Boolean CPoint::operator > ( CPoint point ) {
return this -> distorigine() > point.distorigine();
};
// •·····································································•
// · Opérateur < ·
// •·····································································•
//
//
// Description
// ___________
//
// Cette opérateur permet d'indiquer si l'opérateur est supérieur
// à celui comparer.
Boolean CPoint::operator < ( CPoint point ) {
return this -> distorigine() < point.distorigine();
};
// •·····································································•
// · Opérateur >= ·
// •·····································································•
//
//
// Description
// ___________
//
// Cette opérateur permet d'indiquer si l'opérateur est inférieur ou égal
// à celui comparer.
Boolean CPoint::operator >= ( CPoint point ) {
return this -> distorigine() >= point.distorigine();
};
// •·····································································•
// · Opérateur <= ·
// •·····································································•
//
//
// Description
// ___________
//
// Cette opérateur permet d'indiquer si l'opérateur est supérieur ou égal
// à celui comparer.
Boolean CPoint::operator <= ( CPoint point ) {
return this -> distorigine() <= point.distorigine();
};
// •·····································································•
// · Opérateur == ·
// •·····································································•
//
//
// Description
// ___________
//
// Cette opérateur permet d'indiquer si l'opérateur est égal
// à celui comparer.
Boolean CPoint::operator == ( CPoint point ) {
return this -> distorigine() == point.distorigine();
};
// •·····································································•
// · Procédure fixeposition ·
// •·····································································•
//
//
// Description
// ___________
//
// Cette procédure fixe la nouvelle position de la coordonnée.
void CPoint::fixeposition ( double nouveaux, double nouveauy ) {
m_X = nouveaux, m_Y = nouveauy;
};
// •·····································································•
// · Fonction demandex ·
// •·····································································•
//
//
// Description
// ___________
//
// Cette fonction demande la coordonnée horizontal de la position
// actuel à partir duquel sont effectuées les calculs.
double CPoint::demandex ( void ) {
return m_X;
};
// •·····································································•
// · Fonction demandey ·
// •·····································································•
//
//
// Description
// ___________
//
// Cette fonction demande la coordonnée vertical de la position
// actuel à partir duquel sont effectuées les calculs.
double CPoint::demandey ( void ) {
return m_Y;
};
// •·····································································•
// · Fonction demandey ·
// •·····································································•
//
//
// Description
// ___________
//
// Cette procédure permet l'affichage à une position texte d'écran
// la position actuel du couple.
void CPoint::afficherxy ( char x, char y ) {
gotoxy( x, y );
printf( "(%.2f,%.2f)\r\n", m_X, m_Y );
};
// •·····································································•
// · Procédure dephasage ·
// •·····································································•
//
//
// Description
// ___________
//
// Cette procédure applique un déphasage à une coordonnée sans changer la
// coordonnée d'origine, mais seulement le couple.
void CPoint::dephasage ( double nouveaux, double nouveauy ) {
m_X += nouveaux, m_Y += nouveauy;
};
// •·····································································•
// · Procédure distorigine ·
// •·····································································•
//
//
// Description
// ___________
//
// Cette fonction affiche la distance à partir de l'origine.
double CPoint::distorigine ( void ) {
double distorigine = ( sqrt( pow( m_X, 2 ) + pow( m_Y, 2 ) ) );
return distorigine;
};
//_________________________________________________________________________
Ensuite le fichier d'entête «cpolygone.h»:
// cpolygone.h
// •·········································································•
// · ·
// · C P o l y g o n e ·
// · (Entête) ·
// · ·
// · Programmeur: Sylvain Maltais ·
// · Date: 1999-02-25 ·
// · ·
// · Description ·
// · ___________ ·
// · ·
// · Ce fichier contient les entêtes du problèmes de calcul de la distance ·
// · d'un polygone. ·
// · ·
// •·········································································•
#ifndef __cpolygone
#define __cpolygone
#include "cpoint.h"
class CPolygone {
private:
CPoint *m_point;
int m_nbcote;
public:
// Ce constructeur initialise la figure par défaut sous l'aspect
// d'un triangle.
CPolygone ( void );
// Ce destructeur initialise la figure par défaut sous l'aspect
// d'un triangle.
CPolygone ( CPoint *point, int nbcote );
// Cette opérateur permet d'affecter les valeurs d'un autre polygone
// à celui-ci.
CPolygone & operator = ( CPolygone & copie );
// Cette fonction retourne le nombre de côté que le polygone.
int nombrecote ( void );
// Cette fonction retourne une liste de les points du polygone.
CPoint * demandepoint ( void );
// Cette fonction retourne le périmètre du polygone.
double perimetre ( void );
// Cette procédure permet d'effectuer un déphasage de chacun des points
// du polygone.
// void dephasage ( double nouveaux, double nouveauy );
void dephasage ( CPoint point );
};
#endif
Ensuite le fichier de code source «cpolygon.cpp»:
// cpolygon.cpp
// •·········································································•
// · ·
// · C P o l y g o n e ·
// · (Code Source) ·
// · ·
// · Programmeur: Sylvain Maltais ·
// · Date: 1999-02-25 ·
// · ·
// · Description ·
// · ___________ ·
// · ·
// · Ce fichier contient les sources du problèmes de calcul de la distance ·
// · d'un polygone. ·
// · ·
// •·········································································•
#include <assert.h>
#include "CPOLYGON.H"
// •·····································································•
// · Constructeur ·
// •·····································································•
//
//
// Description
// ___________
//
// Ce constructeur initialise la figure par défaut sous l'aspect d'un triangle.
CPolygone::CPolygone ( void ) {
m_point = new CPoint [ 3 ];
m_point[0].fixeposition( 0, 0 );
m_point[1].fixeposition( 0, 1 );
m_point[2].fixeposition( 1, 0 );
m_nbcote = 3;
}
// •·····································································•
// · Constructeur ·
// •·····································································•
//
//
// Description
// ___________
//
// Ce destructeur initialise la figure par défaut sous l'aspect d'un triangle.
CPolygone::CPolygone( CPoint *point, int nbcote ) {
// vérification
assert( nbcote > 2 );
// allocation de mémoire
m_point = new CPoint [ nbcote ];
for ( int i = 0; i < nbcote; i++ ) m_point[i] = point[i];
m_nbcote = nbcote;
}
// Cette opérateur permet d'affecter les valeurs d'un autre polygone
// à celui-ci.
CPolygone & CPolygone::operator = ( CPolygone & copie ) {
// vérification
assert( copie.m_nbcote > 2 );
delete [] m_point;
m_nbcote = copie.m_nbcote;
m_point = new CPoint[ m_nbcote ];
for( int i = 0; i < m_nbcote; i++ ) m_point[i] = copie.m_point[i];
return * this;
};
// •·····································································•
// · Fonction nombrecote ·
// •·····································································•
//
//
// Description
// ___________
//
// Cette fonction retourne le nombre de côté que le polygone.
int CPolygone::nombrecote ( void ) {
return m_nbcote;
}
// •·····································································•
// · Fonction demandepoint ·
// •·····································································•
//
//
// Description
// ___________
//
// Cette fonction retourne une liste de les points du polygone.
CPoint * CPolygone::demandepoint ( void ) {
return m_point;
}
// •·····································································•
// · Fonction perimetre ·
// •·····································································•
//
//
// Description
// ___________
//
// Cette fonction retourne le périmètre du polygone.
double CPolygone::perimetre ( void ) {
int i;
double total = 0, difx, dify;
for ( i = 0; i < m_nbcote-1; i++ )
difx = fabs ( m_point[i].demandex() - m_point[i+1].demandex() ),
dify = fabs ( m_point[i].demandey() - m_point[i+1].demandey() ),
total = total + ( ( sqrt( pow( difx, 2 ) + pow( dify, 2 ) ) ) );
difx = fabs ( m_point[m_nbcote-1].demandex() - m_point[0].demandex() ),
dify = fabs ( m_point[m_nbcote-1].demandey() - m_point[0].demandey() ),
total = total + ( ( sqrt( pow( difx, 2 ) + pow( dify, 2 ) ) ) );
return total;
}
// •·····································································•
// · Fonction dephasage ·
// •·····································································•
//
//
// Description
// ___________
//
// Cette procédure permet d'effectuer un déphasage de chacun des points
// du polygone.
void CPolygone::dephasage ( CPoint point ) {
for ( int i = 0; i < m_nbcote; i++ )
m_point[i] = m_point[i] + point;
};
Ensuite le fichier de code source «testexer.cpp»:
// testexer.cpp
// •·········································································•
// · ·
// · T e s t e u r - E x e r c i c e ·
// · ·
// · Programmeur: Sylvain Maltais ·
// · Date: 1999-02-04 ·
// · ·
// · Description ·
// · ___________ ·
// · ·
// · Ce fichier contient les sources du test du problèmes de calcul du ·
// · périmètre du polygone. ·
// · ·
// •·········································································•
#include <conio.h>
#include "cpolygon.h"
// •·········································································•
// · Procédure afficherpoint ·
// •·········································································•
//
// Cette procédure affiche le coordonnée d'une liste de «CPoint».
void afficherpoint( CPoint * p, int nbcote ) {
for ( int i = 0; i < nbcote; i++ ) {
printf( "(%lf,%lf) ", p[i].demandex(), p[i].demandey() );
}
printf( "\n" );
}
void main ( void ) {
double x, y;
int i, nbcote;
CPoint *p;
printf( "Exercice");
gotoxy( 1, 4 );
printf( "Nombre de côté ? " );
scanf( "%hd", &nbcote );
p = new CPoint[ nbcote ];
gotoxy( 1, 5 );
for ( i = 0; i < nbcote; i++ ) {
printf( "Entrée la coordonnée X%hd: ", i + 1 );
scanf( "%lf", &x );
printf( "Entrée la coordonnée Y%hd: ", i + 1 );
scanf( "%lf", &y );
p [ i ] . fixeposition ( x, y );
};
{
CPolygone testpoly;
CPolygone polygone( p, nbcote ); // Création de l'objet «CPolygone»
delete p;
testpoly=polygone;
afficherpoint( polygone.demandepoint(), nbcote );
printf ( "Périmètre: %lf\n", testpoly.perimetre() );
printf( "Entrée le déphasage horizontal: " );
scanf( "%lf", &x );
printf( "Entrée le déphasage vertical: " );
scanf( "%lf", &y );
CPoint tpoint( x, y );
polygone.dephasage( tpoint );
afficherpoint( polygone.demandepoint(), nbcote );
}
}
Dernière mise à jour : Mardi, le 24 novembre 2015