IHM/Les classes

Un livre de Wikibooks.
Exercices en langage C++/IHM/Les classes
Aller à : Navigation, rechercher
Modifier
Exercices en langage C++
Les classes

EXERCICE 1:Rectangle Ecrire un programme

utilisant une classe rectangle dont le constructeur prend
deux paramètres, largeur et hauteur et qui offre les
fonctions suivantes :

 calcul du périmètre Sommaire

 calcul de la surface  Avant-propos
 affichage  Notions de base
 Structures de contrôle
ainsi que les accesseurs et mutateurs triviaux (lecture et  Les tableaux
modification de la largeur et de la hauteur).  Les tableaux de char
 Les structures
 Les fonctions
Solution
 Les classes
 Les templates
[ Masquer ]  La STL
 Les fichiers
Découverte et travail des classes. Utilisation d'un
constructeur et d'un destructeur. Liens
 Programmation C plus plus
 Programmation C++ (débutant)
#include<iostream>  IHM en C++ avec wxWidget
 Programmation C
using namespace std;
 Exercices en langage C
class Rectangle
{ Modifier ce modèle
public:
Rectangle(unsigned int initLargeur, unsigned int initHauteur);
~Rectangle();
unsigned int getLargeur() const { return largeur; };
unsigned int getHauteur() const { return hauteur; };
unsigned int perimetre() const { return 2*(largeur+hauteur); };
unsigned int surface() const { return largeur * hauteur; };
void setLargeur(unsigned int newLargeur) { largeur = newLargeur; };
void setHauteur(unsigned int newHauteur) { hauteur = newHauteur; };
void afficher();

private:
unsigned int largeur;
unsigned int hauteur;
};

Rectangle::Rectangle(unsigned int initLargeur, unsigned int initHauteur)

{
largeur = initLargeur;
 hauteur = initHauteur;
}

Rectangle::~Rectangle()
{
}

void Rectangle::afficher()
{
for(unsigned int i=0; i < hauteur; i++)
{
for(unsigned int j=0; j < largeur; j++)
cout << "*";
cout << endl;
}
}

int main()
{
Rectangle monRectangle(0,0);
char choix = '0';
unsigned int value;

while(true)
{
do
{
cout << " Rectangle - Menu" << endl;
cout << "1 - Modifier largeur du rectangle" << endl;
cout << "2 - Modifier hauteur du rectangle" << endl;
cout << "3 - Calculer les propriétés du rectangle" << endl;
cout << "4 - Afficher le rectangle" << endl;
cout << "5 - Quitter" << endl;

cin >> choix;

}while(choix < '1' || choix > '5');

switch(choix)
{
case '1':
cout << "Nouvelle largeur : ";
cin >> value;
monRectangle.setLargeur(value);
break;
case '2':
cout << "Nouvelle hauteur : ";
cin >> value;
monRectangle.setHauteur(value);
break;
case '3':
cout << "Périmètre : " << monRectangle.perimetre() << endl;
cout << "Surface : " << monRectangle.surface() << endl;
break;
case '4':
monRectangle.afficher();
break;
case '5':
exit(0);
break;
default:
cout << "Erreur ! Choix invalide." << endl;
 exit(1);
}
}

return 2;
}

MZM4444 24 octobre 2010 à 15:49 (CEST)

EXERCICE2:Pile d'entiers Une pile est un ensemble dynamique d’éléments où le retrait se

fait d’une façon particulière. En effet, lorsque l’on désire enlever un élément de l’ensemble,
ce sera toujours le dernier inséré qui sera retiré. Un objet pile doit ré pondre aux fonctions
suivantes:

-Initialiser une pile

-Empiler un élément sur la pile (push)

-Dépiler un élément de la pile (pop)

pour cela nous allons supposer que les éléments à empiler sont de type int.

Le programme main comprend la définition d'une classe pile et un programme de test qui crée
deux piles p1 et p2,empile dessus des valeurs

entières et les dépiler pour vérifier les opérations push et pop.

Solution

[ Masquer ]

Découverte et travail des classes. Utilisation d'un constructeur et d'un destructeur.

#include<iostream.h>

class pile

int *tab;

int k; //indice de la 1er position vide

int max;

pile (int taille =100);

~pile();

int push int x; //empiler X

int full();
int empty ();

int pop; int &x; //dépiler le dernier éllement

.

MZM4444 24 octobre 2010 à 15:47 (CEST)

EXERCICE 3:Fichier

Imaginons une application qui traite des fichiers. Ces fichiers vont être lus en mémoire, traités
puis sauvegardés. Une fois lu en mémoire, un fichier a deux caractéristiques, une adresse à
partir de laquelle se situe le fichier et une longueur, ce qui se concrétisera par un pointeur et
une longueur en nombre d’octets. Imaginons la classe "Fichier" avec un constructeur et un
destructeur et les trois méthodes suivantes:

-la méthode "Creation" qui va allouer un certain espace à partir du pointeur P,

-la méthode "Remplit" qui va remplir arbitrairement cet espace (ces remplissages arbitraires
sont la preuve de la bonne gestion mémoire car l’accès à une zone non déclarée provoque une
violation d’accès),

-la méthode "Affiche" qui va afficher la zone mémoire pointée par P.

Puis écrivons un programme maître qui instancie notre classe par new, appelle nos trois
méthodes et détruit l’objet par delete.

Solution

[ Masquer ]

Découverte et travail des classes. Utilisation d'un constructeur et d'un destructeur.

#include <iostream.h>

// déclaration de la classe Fichier

class Fichier

char* P;

unsigned int Lg;

public:

Fichier();

~Fichier();

bool Creation(unsigned int);

void Remplit();

void Affiche();

};

// constructeur

Fichier::Fichier()

P=NULL;

Lg=0;

// destructeur

Fichier::~Fichier()

delete P;

// méthode Creation

bool Fichier::Creation(unsigned int L)

if((P=(char*)malloc(L))==NULL) return false;

Lg=L;

return true;

// Méthode Remplit

void Fichier::Remplit()

for(unsigned int i=0;i<Lg;i++) P[i]='a';

// Méthode Affiche
void Fichier::Affiche()

for(unsigned int i=0;i<Lg;i++) cout<<P[i];

//-----Programma maître (main)--------------

void main(void)

Fichier* f=new Fichier();

if (f->Creation(10))

f->Remplit();

f->Affiche();

delete f;

MZM4444 24 octobre 2010 à 15:47 (CEST)

EXERCICE1(TP3):

réaliser une classe point permettant de manipuler un point d'un plan.on prévoira:

-un point est définit par ses coordonnées x et y (des membres privés)

-un constructeur (vous pouvez également implémenter les trois types de constructeur)

-une fonction membre déplace effectuant une translation définie par ses deux arguments dx et
dy (double)

-une fonction membre affiche se contentant d'afficher les coordonnées cartésiennes du point.

-une fonction membre saisir se contentant de saisir les coordonnées cartésiennes du point.

-une fonction membre distance effectuant calculant la distance entre deux point.

-une fonction membre milieu donnant le milieu d'un segment.

on écrira séparément:

-un ficher source constituant la déclaration et la définition de la classe.

-un petit programme d'essai (main) gérant la classe point.

Solution

[ Masquer ]

Découverte et travail des classes. Utilisation d'un constructeur et d'un destructeur.

//ficher source
#include <iostream.h>
#include <math.h>
class point
{
double x;
double y;
public:
point();
point(double,double);
point(point &);
~point();
double get_x();
double get_y();
void set_x(double x1);
void set_y(double y1);
point deplace(double dx, double dy);
void affiche();
void saisir();
double distance(point &);
point milieu(point &);

};

point::point()
{}
point::point(double a,double b)
{
x=a;
y=b;
}
point::point(point &p)
{
set_x(p.get_x());
set_y(p.get_y());
}
point::~point()
{}
double point::get_x()
{
return x;
}
double point::get_y()
{
return y;
}
void point::set_x(double a)
{
x=a;
}
void point::set_y(double a)
{
y=a;
}
point point::deplace(double dx,double dy)
{

set_x(get_x()+dx);

set_y(get_y()+dy);
return *this;

}
double point::distance (point &p)
{
double p1,x1,x2;
x1=(get_x()-p.get_x())*(get_x()-p.get_x());
x2=(get_y()-p.get_y())*(get_y()-p.get_y());
//p1=sqrt(((get_x()-p.x)*((get_x()-p.x))+((get_y()-p.y)*(get_y()-
p.y)));
p1=sqrt(x1+x2);
return p1;
}
void point::affiche()
{
cout<<"les coordonnées sont:"<<endl;
cout<<"x="<<get_x()<<endl;
cout<<"y="<<get_y()<<endl;
}
void point::saisir()
{
cout<<"donnée les coordonnées:"<<endl;
cout<<"x="<<endl;
cin>>x;
cout<<"y="<<endl;
cin>>y;
}
point point::milieu(point &p)
{
point p1;
p1.x=(get_x()+p.get_x())/2;
p1.y=(get_y()+p.get_y())/2;
return p1;
}

//programme d'essai(main)

#include<iostream.h>
#include "pointt.h"
void main()
{point p(1,1);
point x(5,5);
point c;

p.affiche();
p.deplace(5,5);
p.affiche();
cout<<"la distance est : "<<p.distance(x);
c=p.milieu(x);
c.affiche();
}

MZM4444 26 octobre 2010 à 18:20 (CEST)

Exercice 1 : la classe Compteur

On souhaite implémenter une classe représentant un compteur entier. Un tel objet se

caractérise par :

Une valeur entière, positive ou nulle, nulle à l'origine.

Le fait qu'il ne peut varier que par pas de 1 (incrémentation ou décrémentation). On convient
qu'une décrémentation d'un compteur nul est

sans effet.

Il s'agit de créer une classe Compteur pour rendre le service demandé. On écrira en outre un
petit programme de test qui :

1. créera un compteur et affichera sa valeur;

2. l'incrémentera 10 fois, puis affichera à nouveau sa valeur;

3. le décrémentera 20 fois, puis affichera une troisième fois sa valeur

La sortie de ce programme doit donner (quelque chose comme) "0 10 0"

Solution

[ Masquer ]

Découverte et travail des classes. Utilisation d'un constructeur et d'un destructeur.

Fichier Compteur.h : déclaration de la classe Compteur

class Compteur { protected: /* i.e. visible des classes dérivées */
int _valeur; public: /* i.e. l'interface de la classe */
Compteur(); /* le constructeur, invoque a la création
*/
void incr();
void decr();
int valeur(); /* permet un accès "read-only" a l'attribut
*/
};
Fichier Compteur.C : implémentation de la classe Compteur
#include <iostream.h>
#include "Compteur.h"

/*************************************************************/
Compteur :: Compteur() {
_valeur = 0;
}

/*************************************************************/
void Compteur :: incr() {
_valeur ++;
}

/*************************************************************/
void Compteur :: decr() {
if (_valeur>0) _valeur--;
}

/*************************************************************/
int Compteur :: valeur() {
return _valeur;
}

Fichier testCompteur.C : programme principal

#include <iostream.h>
#include "Compteur.h"

/*************************************************************/
int main () {

Compteur c; // automatiquement égal a 0 par le

constructeur

cout << c.valeur() << endl;

for (int i=0; i<10; i++)
c.incr();
cout << c.valeur() << endl; // le compteur est passe à 10
for (int i=0; i<20; i++) // "i" est local au "for" !!!
c.decr();
cout << c.valeur() << endl; // le compteur est redescendu à 0

return 0; // pour l'OS

}

Exercice 5 :

1/ On voudrait gérer les étudiants d’une institution à l’aide d’une classe Etudiant définie par :

les attributs suivants :

- nom : nom d’un étudiant

- prénom: prénom d’un étudiant

- tabnotes : tableau contenant les notes d’un étudiant, sachant qu’un étudiant a au total 10
notes.

les méthodes suivantes :

- void saisie (), permettant la saisie d’un étudiant

- void affichage (), permettant l’affichage d’un étudiant

- float moyenne (), retourne comme résultat la moyenne des notes d’un étudiant.

- int admis (), retourne comme résultat la valeur 1, si un étudiant est admis et la valeur 0,
sinon. Un étudiant est considéré comme étant

admis lorsque la moyenne de ses notes est supérieure ou égale à 10.

- int exae_quo (Etudiant E), retourne comme résultat la valeur 1, si deux étudiants ont la
même moyenne et la valeur 0, sinon.

Ecrire la classe Etudiant dans le langage C++.

2/ On voudrait maintenant représenter, à l’aide d’une nouvelle classe Etudiant_en_Maitrise,

certains étudiants particuliers dans cette

institution qui sont les étudiants en dernière année d’études. Ces étudiants possèdent en effet
un attribut supplémentaire : note_memoire,

qui représente la note de leur mémoire de fin d’études.

Les méthodes à associer à cette classe sont les suivantes :

- void saisie (), permettant la saisie d’un étudiant en maîtrise

- void affichage (), permettant l’affichage d’un étudiant en maîtrise

- float moyenne (), retourne comme résultat la moyenne des notes d’un étudiant en maîtrise

- int admis (), retourne comme résultat la valeur 1, si un étudiant est admis et la valeur 0,
sinon. Un étudiant en maîtrise est considéré

comme étant admis lorsque, d’une part, la moyenne de ses notes est supérieure ou égale à 10
et d’autre part la note obtenue pour son mémoire

de fin d’études est supérieure ou égale à 10.

- int exae_quo (Etudiant_en_Maitrise E), retourne comme résultat la valeur 1, si deux

étudiants ont d’une part la même moyenne et d’autre

part, la même note de mémoire et retourne la valeur 0, sinon.

a) Quelles sont les méthodes qui sont à redéfinir dans la classe Etudiant_en_Maitrise ?

b) Ecrire la classe Etudiant_en_Maitrise dans le langage C++.

Solution

[ Masquer ]

Découverte et travail des classes. Utilisation d'un constructeur et d'un destructeur.

1/

class Etudiant

{ private:

char nom[50], prenom[50];

float tabnotes[10] ;

public :

void saisie () ;

void affichage () ;

float moyenne() ;

int admis() ;

int exae_quo (Etudiant E) ;

} ;

void Etudiant ::saisie ()

{ int i ;

cout << "Donner le nom :" ;

cin >> nom ;

cout << "Donner le prénom :" ;

cin >> prenom ;

cout << "Saisie des notes \n" ;

for (i = 0 ; i < 10 ; i++)

cout << "Donner la note N°" << i<< " : " ;

 cin >> tabnotes[i] ;

void Etudiant ::affichage ()

{ int i ;

cout << "Le nom :"<<nom<< endl ;

cout << "Le prénom :" <<prenom<< endl ;

for (i = 0 ; i < 10 ; i++)

cout << "La note N°" << i << "est " <<
tabnotes[i]<< endl ;

float Etudiant ::moyenne()

{ int i ;

float som = 0;

for (i = 0 ; i < 10 ; i++)

som + = tabnotes[i] ;

return (som/10)

int Etudiant ::admis()

{ if (moyenne() >= 10) return (1); else return (0);}

int Etudiant ::Exae_quo(Etudiant E)

{ if (moyenne() == E.moyenne()) return (1); else return (0);}

2/

a) Les méthodes qui sont à redéfinir dans la classe Etudiant_en_Maitrise

sont : saisie, affichage, admis et esae_quo.

b)

class Etudiant_en_Maitrise : public Etudiant

{ private:

float note_memoire ;

public :

void saisie () ;

void affichage () ;
 int admis() ;

int exae_quo (Etudiant_en_Maitrise E) ;

} ;

void Etudiant_en_Maitrise ::saisie ()

{ Etudiant ::saisie () ;

cout << "Donner la note du mémoire :" ;

cin >> note_memoire ;

void Etudiant_en_Maitrise ::affichage ()

{ Etudiant :: affichage () ;

cout << "La note du mémoire :" << note_memoire<< endl ;

int Etudiant_en_Maitrise ::admis()

{ if ((moyenne() >= 10) && (note_memoire >=10))return (1); else return

(0);}

int Etudiant_en_Maitrise ::Exae_quo(Etudiant E)

{ if ((moyenne() == E.moyenne()) && (note_memoire == E.note_memoire))

return (1); else return (0);}

Récupérée de «
http://fr.wikibooks.org/wiki/Exercices_en_langage_C%2B%2B/IHM/Les_classes »
Catégorie : Exercices en langage C++ (livre)