Accueil de Gladir.com Notes légales de Gladir.com Flux RSS des nouvelles du site Gladir.com - Langage de programmation - C++ - Mathématique - Polygone Section du logiciel DOS «MonsterBook» Inventaire de la bibliothèque de Gladir.com Entrée administrateur


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: Vendredi, le 10 mars 2006