APPLICATION OBJET EN MODE CONSOLE

1. Génération du projet

Pour développer une application objet sans avoir à gérer les fenêtres, on peut utiliser le mode console. L'exécutable sera
lancé dans une fenêtre "Console". Pour cela, il suffit de choisir dans le menu principal de Visual : Fichier->Nouveau-
>Projet et de remplir la boite de dialogue comme indiqué ci-dessous (dans les « types de projet », à gauche, Visual C++
doit être sélectionné).

L'application que nous allons créer

comportera deux classes. La classe de
base sera la classe représentant (de
manière très simpliste !) les êtres
vivants d'une manière générale
(CVivant). Ceux ci pourront naître,
manger, grandir, vieillir et mourir. Les
variables qui les caractériseront seront
donc leur poids, taille et age.
Nous dériverons ensuite la classe
CHumain de la classe CVivant. Les
objets de cette classe seront soit
masculin soit féminin, et pourront de
plus travailler et s'amuser. Ils auront
donc deux variables membres sup-
plémentaires : type et finance.

Pour créer la première classe, la partie gauche de l'écran

doit montrer les classes présentes dans le projet (onglet
Affichage de classes). On clique sur le bouton droit sur
Evolution, et on choisit dans le menu contextuel
Ajouter->Classe. Dans la boite de dialogue qui
apparaît, choisir Classe C++, Il suffit alors de donner le
nom à la classe : CVivant.
La classe est créée (Vivant.h contient la définition de la
classe et contiendra les prototypes des fonctions et
variables membres, Vivant.cpp contiendra le corps des
fonctions membres).

Vivant.h est accessible en double cliquant sur le nom de la classe dans le navigateur (partie gauche de l’écran).
Les fonctions membres (pour l'instant constructeur et destructeur) sont accessibles dans la partie inférieure du
navigateur de classes et en double cliquant sur le nom des fonctions membres. La partie droite de l'écran sert à l'édition
du code source.

2. Ajout de variables membres

On peut évidemment ajouter les variables membres "à

la main" dans vivant.h, mais l'interface nous permet de
le faire automatiquement.
Pour cela, on clique avec le bouton de droite sur le
nom de la classe (CVivant), et on choisit dans le menu
contextuel Ajouter -> Une variable (voir figure).

8
On ajoute ainsi trois variables public, de type int : Age, Poids, Taille. Ces trois variables apparaissent maintenant dans
l'arborescence de la classe.

3. Ajout de fonctions membres

On peut procéder de la même manière pour ajouter les

fonctions membres : Manger, Grandir, et Vieillir
(voir figure ci-contre).
Les fonctions ici ne prennent pas de paramètres. Dans
le cas contraire, il faudrait indiquer explicitement ces
paramètres entre les parenthèses dans la déclaration de
la fonction, comme pour une déclaration "manuelle".

L'avantage de la déclaration automatique est qu'elle modifie aussi bien Vivant.h que Vivant.cpp, et évite des erreurs de
frappe. Ainsi, Vivant.h et Vivant.cpp deviennent :

Vivant.h Vivant.cpp
CVivant::CVivant()
class CVivant {
{ }
public: CVivant::~CVivant()
void Vieillir(void); {
void Grandir(void); }
void Manger(void); void CVivant::Manger(void)
int Taille; {
int Poids; }
int Age; void CVivant::Grandir(void)
CVivant(void); {
virtual ~CVivant(void); }
void CVivant::Vieillir(void)
}; {
}

Il suffit maintenant de remplir les corps des fonctions, avec ici des éléments très simples : on insérera Poids++,
Taille++ et Age++ dans les fonctions concernées.
De plus, on initialisera les trois variables à 0 dans le constructeur.

4. Le programme principal

Pour tester cette classe, il est ici nécessaire de
modifier la fonction wmain, équivalente du
main en C classique. Cette fontion a été
ajoutée automatiquement : pour y accéder il
faut choiri « Fonctions globales et variables »
dans le navigateur de classes, puis double
cliquer sur wmain dans la partie inférieure de ce navigateur.
Ceci permet d’éditer le fichier Evolution.cpp qui contient la fonction
wmain. Dans ce fichier, on va utiliser la classe CVivant. Il est donc
nécessaire d'inclure le fichier vivant.h.

On déclare ensuite une fonction main, dans laquelle on déclare un objet de classe CVivant, objet que l'on appellera
Animal.

CVivant Animal; // appel du constructeur

On affichera ensuite les valeurs des variables membres de cet objet à l'aide d'un simple printf. On peut ensuite tester
l'appel aux différentes fonctions membres et afficher le résultat. On pourra introduire une pause dans le déroulement
du programme par appel à la fonction _getch.
Pour construire le programme exécutable, choisir Générer->Générer la solution (F7).
On peut lancer le programme en mode Debug (phase de développement) par F5 ou en mode Release par CTRL-F5.
9
Remarque : on pourrait également déclarer un tableau d'objet par
CVivant Animal[10];
On accéderait alors aux variables membres par
Animal[3].Taille = 3 ; // par exemple pour l'élément n°3
ou aux fonctions membres par :
Animal[3].Manger(); // seul le poids de Animal[3] sera alors modifié.

5. Création d'une classe dérivée

Pour créer la classe CHumain dérivant de CVivant il

suffit de cliquer dans la partie gauche de l'écran, sur
Evolution, à l'aide du bouton droit, et de choisir New
Class.

Dans la boite de dialogue qui s'affiche, il suffit de

spécifier que la nouvelle classe dérive de CVivant (voir
figure ci-contre).

Par héritage, tout objet de classe CHumain possède les trois variables et les fonctions membres de la classe CVivant. Il
est donc inutile de les redéfinir.
En revanche, il faut ajouter deux variables membres. La première, de type int, s'appellera Finances. La seconde de type
genre, s'appellera Famille. Pour utiliser cette dernière, il est nécessaire de définir les valeurs possibles des variables de
type genre. On utilise pour ceci la syntaxe suivante :
#pragma once
enum genre
{
HOMME,
FEMME ,
AUTRE
};

Les variables de type genre pourront donc prendre les valeurs HOMME (valeur 0) ou FEMME (valeur 1), AUTRE
(valeur 2).
Cette déclaration doit être mise dans le fichier entête correspondant au programme principal, de manière à pouvoir être
utilisée dans toutes les classes.
Ajouter donc un fichier de type header ou entête au projet (Fichier->Nouveau->Fichier), en le nommant evolution.h (enregistrez
le bien dans le dossier du projet, au même niveau que les autres fichiers .cpp et .h), et ajoutez exactement les lignes ci-dessus.
Ajoutez ensuite #include "evolution.h" dans le fichier evolution.cpp, afin que les variables de type genre puissent y
être utilisées.
Définissez donc Famille et Finances comme précisé ci-dessus.

Pour initialiser les valeurs des variables à la "naissance" de l'objet, nous allons surcharger le constructeur par défaut,
c'est à dire ajouter un constructeur qui admettra 4 paramètres. Pour cela, ajoutez une fonction membre de manière
classique, mais sans mettre de type, et en suivant le prototype suivant :
CHumain(genre Finit, int TailleInit, int PoidsInit, int FinancesInit)

Editez ensuite le corps de la fonction :

CHumain::CHumain(genre Finit, int TailleInit, int PoidsInit, int FinancesInit)

{
Famille=Finit;
Taille=TailleInit;
Poids=PoidsInit;
Finances=FinancesInit;
}

Il s'agit donc du deuxième constructeur. Si, dans le programme principal, on écrit

CHumain Jean;

10
C'est le premier constructeur qui sera appelé (il n'a aucun paramètre). Les variables seront donc initialisées à 0, car c'est
ce que nous avons spécifié dans le constructeur de la classe CVivant.

Si on déclare un objet CHumain de la manière suivante :

CHumain Jean(HOMME,35,3500,500);

C'est le deuxième constructeur qui sera appelé, et toutes les variables seront initialisées avec les valeurs passées en
paramètre.

Si l'on appelle ensuite

Jean.Manger();
Automatiquement, c'est la fonction de la classe CVivant qui sera appelée, car elle n'a pas été redéfinie dans la classe
CHumain.

Si l'on redéfinit une des fonctions, prenant en compte les problèmes de financement, par exemple, on peut surcharger
la fonction Manger (il faut pour cela ajouter cette fonction membre à la classe CHumain. Son corps peut être le suivant
:
void CHumain::Manger()
{
Finances--;
Poids++;
}

Un appel de type
Jean.Manger();
augmentera donc le poids de 1, et diminuera les finances d'autant.
On peut également, dans cette fonction, appeler la fonction correspondante de la classe mère, ce qui évite de réécrire le
code si celui-ci est lourd :

void CHumain::Manger()
{
Finances--;
CVivant::Manger(); // appel de la fonction manger de la classe mère
}

On peut également ajouter des fonctions membres à la classe CHumain, qui n'existent pas dans la classe CVivant,
comme la fonction Travailler ou Samuser, dont des exemples sont donnés ci dessous.

void CHumain::Travailler() void CHumain::Samuser()

{ {
Poids--;
Finances++; Finances-=5;
} }

11