Série 6 :
Polymorphisme (1/2).

Préliminaires :

Avant de commencer les exercices décrits dans cette série, créez le répertoire ~/Desktop/myfiles/cpp/serie19 et travaillez dans ce répertoire.

Exercice 1 : formes polymorphiques (niveau 1)

Le but de cet exercice est de vous illustrer les problèmes qui peuvent se poser lorsque l'on veut manipuler des objets de façon polymorphique (un objet pouvant se substituer à un autre objet).

Il s'agit de manipuler quelques formes géométriques simples en leur associant une méthode qui affiche leur description.

16.1 Formes

Dans un fichier formes.cc, définissez une classe Forme en la dotant d'une méthode void description() qui affiche à l'écran : « Ceci est une forme ! » .

Ajoutez au programme une classe Cercle héritant de la classe Forme, et possédant la méthode void description() qui affiche à l'écran : « Ceci est un cercle. ».

Recopiez ensuite la fonction main() suivante, et testez votre programme :

int main() {
 Forme f;
 Cercle c;
 f.description();
 c.description();
 return 0;
}

Ajoutez maintenant ceci à la fin de la fonction main():

 Forme f2(c);
 f2.description();

Testez ensuite à nouveau votre programme.

Voyez-vous vu la nuance ?
Pourquoi a-t-on ce fonctionnement ?

Continuons nos prospections...

Ajoutez encore au programme une fonction :

void affichageDesc(Forme& f)

qui affiche la description de la forme passée en argument en utilisant sa méthode description().

Finalement, modifiez le main ainsi :

 
int main() {                 
 Forme f;                    
 Cercle c;                    
 affichageDesc(f);
 affichageDesc(c);
 return 0;
}

Testez le programme... Le résultat vous semble-t-il satisfaisant ? Pourquoi?

Modifiez le programme (ajoutez 1 seul mot) pour que le résultat soit plus conforme à ce que l'on pourrait attendre.

16.2 Formes abstraites

Recopiez le programme précédent dans le fichier formesabstraites.cc, et modifiez la classe Forme de manière à en faire une classe abstraite en lui ajoutant la méthode virtuelle pure double aire() permettant de calculer l'aire d'une forme.

Écrivez également une classe Triangle et modifiez la classe Cercle existante héritant toutes deux de la classe Forme, et implémentant les méthodes aire() et description().

Vous l'aurez deviné, la classe Triangle aura comme attributs base et hauteur ainsi qu'un constructeur adéquat, et Cercle aura
comme seul attribut rayon (ainsi qu'un constructeur adéquat).

Modifiez la fonction affichageDesc pour qu'elle affiche, en plus, l'aire de la forme passée en paramètre et testez avec la fonction main suivante :

 
int main() {                 
 Cercle c(5);                    
 Triangle t(10, 2);
 affichageDesc(t);
 affichageDesc(c);
 return 0;
}

Exercice 2 : Puissance 4 (niveau 3)

On envisage de programmer un jeu de puissance 4 (consistant à aligner quatre pions de même couleur soit horizontalement, soit verticalement, soit en diagonale). Le but de cet exercice est de fournir une première solution (sans interface graphique).

Pour programmer ce jeu, on distinguera trois types d'« objets » : des joueurs, un jeu, et une partie.

Un Joueur sera caractérisé par une Couleur (rouge ou jaune, par exemple), un nom et une méthode virtuelle pure jouer(Jeu&).

Un Jeu sera une table carrée pouvant contenir des pions de Couleur ou être vide. On devra pouvoir donner la taille de la table lors de l'initialisation d'un Jeu (valeur par défaut : 8).

On fournira également une méthode jouer() prenant un numéro de colonne et une couleur. Lorsque cela est possible (colonne non pleine), cette méthode ajoute, dans la colonne correspondante et à la position libre la plus basse, le pion de la couleur passée en paramètre. Elle retourne un booléen indiquant si le pion a pu être placé ou non.

On ajoutera de plus à la classe Jeu une méthode gagnant qui retourne la couleur du gagnant, s'il y en a un, et « vide » sinon.

La classe Partie sera constituée d'un tableau de deux joueurs (dont le premier est celui qui commence) et d'un Jeu.

Pour pouvoir effectivement jouer, il faut maintenant implémenter des joueurs. Considérons deux types de joueurs :

• les joueurs humains, pour lesquels la méthode jouer consiste à afficher le Jeu, à demander à l'utilisateur le numéro de colonne à jouer, jusqu'à ce que le coup soit valide ; puis à le jouer effectivement sur le jeu ;

• l'ordinateur, pour lequel dans le cadre de cet exercice la méthode jouer sera très simple : jouer la première position possible rencontrée. L'étudiant intéressé pourra bien entendu compliquer à souhait cette méthode et implémenter des stratégies plus évoluées.

  On informera l'utilisateur du coup joué par un message à l'écran.

  Cette méthode dans sa version la plus simple ne contient donc vraiment que quatre lignes de code !

Tester le programme en créant une partie dans le main, avec un Joueur humain et un Joueur ordinateur (lequel commence).

Pour cela la classe Partie devra avoir une méthode lancer qui fait jouer les joueurs tour à tour, qui vérifie à chaque fois s'il y a un gagnant ou si le jeu est plein, et qui affiche le résultat en conséquence.

Exemple de déroulement

Entrez votre nom :
Corinne Titgoute

Le programme a joué en 1


#
--------
12345678
Joueur Corinne Titgoute, entrez un numéro de colonne
  (entre 1 et 8) : 12
-> Coup NON valide.
Joueur Corinne Titgoute, entrez un numéro de colonne
  (entre 1 et 8) : 1
Le programme a joué en 1





#
O
#
--------
12345678

Joueur Corinne Titgoute, entrez un numéro de colonne
  (entre 1 et 8) :