Voici un exemple de petit programme C++ sur les calculs de Polygone que j'ai fait à l'école. Ce programme est divisé en 5 fichiers avec des classes et constructeurs et tous les accessoires classiques de la programme moderne du langage C++. Il y a deux fichiers d'entête «CPoint.H» et «cpolygon.h» lequel contiennent les définitions d'entête d'une bibliothèque. Il y a deux fichiers contenant le code source des classes «CPoint.CPP» et «cpolygon.cpp». Enfin, il y a un fichier «testexer.cpp» contenant le programme principal permettant de tester les classes. Tout d'abord le fichier d'entête «CPoint.H»:
// 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