PROFDINFO.COM

Votre enseignant d'informatique en ligne

Laboratoire 5- Les modules

Exercice 5.1

Reprenez l'exercice 4.5 et créez un module (c'est-à-dire un fichier .h et un fichier .cpp) mathématique avec les fonctions Carre, ValeurAbsolue, RacineCarre, Minimum et Maximum. De plus, créez un programme principal qui permettra de bien tester ces fonctions. N'oubliez pas d'utiliser le mécanisme de prévention des inclusions multiples. N'oubliez pas non plus les entêtes de fichiers et les entêtes de fonctions.

Exercice 5.2

Reprenez les fonctions développées aux exercices 4.12 et 4.13 et créez un module (c'est-à-dire un fichier .h et un fichier .cpp) de manipulation de chaines de caractères. Créez aussi un programme principal qui permettra de bien tester ces fonctions. N'oubliez pas d'utiliser le mécanisme de prévention des inclusions multiples. N'oubliez pas non plus les entêtes de fichiers et les entêtes de fonctions.

Préparation - Introduction à Simple DirectMedia Layer (SDL) et à l'interface de programmation graphique de KA0

Création d'un nouveau projet

Créez un nouveau projet vide de type Application Console Win32. Supposons pour l'exemple que vous avez créé le projet dans :

C:\Utilisateurs\201701010\Bureau\<NomDeVotreSolution>

(si vous l'avez créé ailleurs, comme sur une clé USB, il se trouvera à l'endroit que vous avez désigné, l'important est de retenir où est ce dossier de solution)

Téléchargement des fichiers

Téléchargez le fichier suivant:

SDL-2.0.4.zip

et décompressez le contenu dans un sous-dossier de votre dossier de solution, par exemple:

C:\Utilisateurs\201701010\Bureau\<NomDeVotreSolution>\SDL-2.0.4\

De cette façon, le dossier SDL-2.0.4 fera partie de votre solution (ce qui vous simplifiera la vie si vous décidez de le transférer ailleurs un jour, la bibliothèque suivra la solution).

Modifications des propriétés du projet

Dans Visual Studio, sélectionnez le menu Projet, puis l'item Propriétés de <NomDeVotreProjet>...

Sous l'onglet Propriétés de configuration, sélectionnez Répertoires VC++ et Répertoires Include.

Ajoutez le chemin d'accès aux fichiers d'entêtes:

$(SolutionDir)\SDL-2.0.4\include

Faites attention! La propriété Répertoires Include contient une liste de répertoires séparés par des point-virgules! Ajoutez le vôtre à la fin, en étant certain qu'il y a un point-virgule entre le dernier de la liste et votre ajout!

sdlconfig

$(SolutionDir) est une variable d'environnement qui contient le chemin du répertoire de votre solution (par exemple C:\Utilisateurs\201701010\Bureau\<NomDeVotreSolution>). Le fait d'utiliser la variable au lieu du chemin absolu vous permettra de déplacer votre dossier de projet n'importe où et que tout continue de compiler -- dans le cas contraire, le compilateur chercherait toujours le dossier C:\Utilisateurs\201701010\Bureau\, même chez vous!

De la même façon, sous Éditeur de liens, sélectionnez Général, puis Répertoires de bibliothèques supplémentaires.

Ajoutez le chemin d'accès aux librairies:

$(SolutionDir)\SDL-2.0.4\lib\x86

Sous l'onglet Propriétés de configuration, sélectionnez Débogage et Environnement.

Entrez la valeur:

PATH=%PATH%;$(SolutionDir)\SDL-2.0.4\lib\x86

PATH est une variable d'environnement qui contient le chemn de tous les dossiers à visiter lorsqu'on cherche un fichier pendant l'exécution. Cette ligne ajoute donc au contenu existant de PATH votre dossier de bibliothèques SDL, ce qui sera fort pratique lorsque vous exécuterez votre programme et qu'il cherchera le fichier SDL.dll qui s'y trouve.

Sous l'onglet Éditeur de liens, Entrée, ajoutez les dépendances supplémentaires SDL2.lib et SDL2main.lib, toujours en les séparant de ce qui est déjà là par des point-virgules!

sdlconfig2

Appliquez les modifications.

Création et ajout des fichiers .cpp et .h

Ajoutez un nouveau fichier source .cpp à votre projet avec le code suivant:

#include "sdlclg.h"

int main(int argc, char *argv[])
{
	// Créer une fenêtre graphique de 640 pixels par 480 pixels
	InitialiserAffichage("Ma premiere fenetre", 640, 480);
	// Remplir la fenêtre avec du rouge
	RemplirFenetre(255,0,0);  
	// Dessiner un rectangle bleu 
	DessinerRectangle(100,100,200,300,0,0,255);
	// Rafraichir la fenêtre 
	RafraichirFenetre();  
	// Attendre 5 secondes
	Attendre(5000);
	// Fermer la fenêtre
	QuitterAffichage();

	return 0;
}

Vous noterez que ce main comporte des paramètres entre parenthèses. Bien que nous ne les utiliserons pas explicitement, ils sont essentiels pour que tout compile. De la même façon, le return 0 à la fin est important (même si partout ailleurs il était facultatif)!

L'interface de programmation graphique de KA0

Copiez les fichiers sdlclg.cpp et sdlclg.h dans le répertoire de votre nouveau projet, à l'endroit où se trouve votre fichier .cpp (par exemple, C:\Utilisateurs\201701010\Bureau\<NomDeVotreSolution>\<NomDeVotreProjet>). Pour ce faire, cliquez avec le bouton de droite sur les liens de la phrase précédente et choisissez "Enregistrer le lien sous".

Dans Visual Studio, ajoutez ces deux fichiers à votre projet en cliquant avec le bouton de droite sur le nom de votre projet dans l'explorateur de solutions et en choisissant "Ajouter élément existant". Sélectionnez les deux fichiers. Vous noterez que le fichier sdlclg.h se retrouvera automatiquement dans la branche "Fichiers d'en-tête" et sdlclg.cpp dans "Fichiers sources", avec votre fichier de code.

Compilez et testez le tout. Vous devriez voir apparaître la fenêtre suivante si tout va bien:

Exercice 5.3 - Le paysage féérique de Noël

Téléchargez ces images de noël et décompressez-les dans votre répertoire de projet, avec vos fichiers de code.

À l'aide d'appels aux fonctions déclarées dans sdlclg.h, creez le joli paysage féérique de Noël suivant:

Exercice 5.4

Créez un module de fonctions de déplacement (c'est-à-dire un fichier .h et un fichier .cpp) avec les quatre fonctions suivantes:

void DeplacerHaut  (int& PosX, int& PosY, int MaxX, int MaxY); 
void DeplacerBas   (int& PosX, int& PosY, int MaxX, int MaxY); 

void DeplacerGauche(int& PosX, int& PosY, int MaxX, int MaxY); 
void DeplacerDroite(int& PosX, int& PosY, int MaxX, int MaxY);

Ces fonctions ont pour objectif de déplacer la position d'une image d'un seul pixel dans une direction souhaitée (haut, bas, gauche ou droite) sans qu'une position devienne négative ou dépasse la valeur maximale passée en paramètre. N'oubliez pas d'utiliser le mécanisme de prévention des inclusions multiples. N'oubliez pas non plus les entêtes de fichiers et les entêtes de fonctions.

Notez bien : vous devez créer un nouveau fichier .h et un nouveau fichier .cpp pour votre module de déplacement et ne pas ajouter ces fonctions à sdlclg!

Reprenez ensuite votre paysage féérique de Noël (exercice 5.3) et modifiez-le de facon à déplacer chacune des images (le traineau, le sapin, les cadeaux et le bonhomme de neige) dans une direction différente. Évidemment, vous devez faire des appels aux fonctions développées plus haut.

Exercice 5.5

Voici un programme sans indentations, sans commentaires, sans fonctions et sans modules. Un programme plutôt difficile à comprendre quoi! Dans un premier temps, compilez et testez le bon fonctionnement de ce programme. Vous aurez besoin pour ce faire des images suivantes: wormsimages.zip.

#include <cmath>

#include "sdlclg.h"

int main(int argc, char *argv[])

{

const int RUSTYX =  302;

const int RUSTYY = 193;

const int FLUFFX = 457;

const int FLUFFY = 286;

const int TAILLE = 64;

const int DISTANCE_COLLISION = 10;

const float ANGLE = 45; 

const float VITESSE = 30; 

const float TEMPSINCREMENT = 0.1f;  

const float GRAVITATION = 9.8f;

const float DUREE = 10.0f;

const float PI = 3.141592653589f;

int Fond  = ChargerImage("fond.bmp");

int Fluff = ChargerImage("Fluff.bmp");

int Rusty = ChargerImage("Rusty.bmp");

int Balle = ChargerImage("Balle.bmp");

float VitesseInitialeX = VITESSE*cos(ANGLE/360.0f*2.0f*PI);

float VitesseInitialeY = -VITESSE*sin(ANGLE/360.0f*2.0f*PI);

bool Gagne = false;

int BalleX = RUSTYX;

int BalleY = RUSTYY;

int Distance; 

int MilieuFluffyX = FLUFFX + TAILLE/2;

int MilieuFluffyY = FLUFFY + TAILLE/2;

int MilieuBalleX;

int MilieuBalleY;

int dx;

int dy;

float Temps;

InitialiserAffichage("Rusty Vs Fluffy", 800, 500);

for(Temps=0.0; Temps<DUREE && !Gagne; Temps+=TEMPSINCREMENT)

{

BalleX = RUSTYX + VitesseInitialeX*Temps;

BalleY = RUSTYY + VitesseInitialeY*Temps + 0.5*GRAVITATION*Temps*Temps; 

AfficherImage(Fond, 0,0);

AfficherImage(Fluff, FLUFFX, FLUFFY);

AfficherImage(Rusty, RUSTYX, RUSTYY);	

AfficherImage(Balle, BalleX, BalleY);

RafraichirFenetre();

MilieuBalleX = BalleX + TAILLE/2;

MilieuBalleY = BalleY + TAILLE/2;

dx = MilieuFluffyX - MilieuBalleX;

dy = MilieuFluffyY - MilieuBalleY;

Distance = dx*dx + dy*dy;

Gagne = Distance < DISTANCE_COLLISION*DISTANCE_COLLISION;

Attendre(1000.0*TEMPSINCREMENT);

}

QuitterAffichage();

return 0;

}

Ensuite, faites le grand ménage dans le code de ce programme en le divisant en fonctions, puis en modules.

Exercice 5.6

On désire faire une programme qui servira d'horloge et de calendrier. Dans un premier temps, le programme demande les minutes, l'heure, le jour de la semaine (lundi, mardi, etc.), la date du mois, le mois et l'année. Ensuite, il attend une minute, puis augmente les minutes de 1. S'il le faut, le programme ajuste les minutes, l'heure actuel, le jour de la semaine, la date du mois, le mois et l'année. Pour ce faire, vous devez savoir qu'il y a 60 minutes dans une heure (!), 24 heures dans une journée (!!), 31 jours par mois les mois de janvier, mars, mai, juillet, août, octobre et décembre, 30 jours les mois d'avril, juin, septembre, et novembre. Le mois de février a 28 jours sauf les années bissextiles où il a 29 jours. Une année est bissextile s'il repecte l'algorithme suivant:

Si Annee % 100 = 0
     Si Annee % 400 = 0
           Bissextile <- Vrai
     Sinon
        Bissextile <- Faux
Sinon
   Si Annee % 4 = 0
        Bissextile <- Vrai
     Sinon
          Bissextile <- Faux

Ensuite le programme attend encore une minute et recommence le processus. Bien sûr, le programme doit afficher ces informations à la console comme par exemple:

Nous sommes dimanche le 1 novembre 2009 et il est 15:09.

Vous devez dans un premier temps produire le diagramme hiérarchique de votre application, décidez des intrants et extrants de chacune de vos fonctions, puis repérer les fonctions qui feront partie d'un module externe. Pour cet exercice, vous devez vous concentrer sur la modularisation du programme en fonctions et sur la division du programme en deux: le programme principal et un module externe.

Afin de créer une horloge réelle, qui semble se mettre à jour, vous pouvez utiliser la fonction system("cls") pour effacer la console et réécrire la nouvelle heure par-dessus, puis la fonction Sleep() qui fonctionne exactement comme Attendre() dans sdlclg : on lui passe un nombre de millisecondes et le programme dort pendant cette période avant de reprendre l'exécution. 1000 millisecondes = 1 seconde, mais pour des fins de tests, vous pouvez faire une horloge où le temps passe plus vite! N'oubliez pas d'inclure Windows.h, la bibliothèque qui contient Sleep().