PROFDINFO.COM

Votre enseignant d'informatique en ligne

Laboratoire 6 - Types et structures

Exercice 6.1

Ecrivez une fonction qui prend en paramètre un tableau de int ainsi que la taille du tableau et qui retourne la somme des nombres dans le tableau. Testez le bon fonctionnement de la fonction à l'aide d'un programme de test.

Exercice 6.2

Ecrivez une fonction qui prend en paramètre un tableau de float ainsi que la taille du tableau et qui retourne le plus grand nombre dans le tableau. Testez le bon fonctionnement de la fonction à l'aide d'un programme de test.

Exercice 6.3

Ecrivez une fonction qui prend en paramètre un tableau de char, la taille du tableau et une valeur. La fonction doit retourner si oui ou non la valeur est présente dans le tableau. Testez le bon fonctionnement de la fonction à l'aide d'un programme de test.

Exercice 6.4

Ecrivez une fonction qui prend en paramètre deux tableaux de long et leur taille respective et qui retourne si oui ou non les deux tableaux sont identiques. Deux tableaux sont identiques s'ils ont la même taille et les mêmes valeurs aux mêmes endroits. Testez le bon fonctionnement de la fonction à l'aide d'un programme de test.

Exercice 6.5

Ecrivez une fonction qui prend en paramètre un tableau de int ainsi que la taille du tableau et qui le place en ordre croissant. Utilisez pour ce faire l'alogrithme de tri par sélection. Testez le bon fonctionnement de la fonction à l'aide d'un programme de test.

Exercice 6.6

Écrivez une fonction qui prend en paramètre un tableau de int à deux dimensions, ainsi que le nombre de lignes du tableau, puis un nombre à trouver dans le tableau. (N'oubliez pas que le nombre de colonnes d'un tableau 2D doit être spécifié entre les crochets et non comme un autre paramètre!). Votre fonction doit parcourir le tableau 2D et compter combien de fois le nombre recherché se trouve dans le tableau. La fonction retourne ensuite ce nombre d'occurrences. Testez le bon fonctionnement de la fonction à l'aide d'un programme de test.

Exercice 6.7

Un étudiant au collège peut être décrit par les informations suivantes:

Nom
Prénom
Numéro d'admission
Son programme d'étude
Session courante d'étude (de 1 à 6)

Créez la structure nécessaire en C++ pour représenter un étudiant.
Déclarez un tableau de 5 étudiants.
Écrivez une fonction qui permettra d'initialiser le tableau d'étudiants. La fonction reçoit un tableau de structures en paramètre et le nombre d'étudiants à initialiser. Pour chaque étudiant, la fonction demande d'entrer les informations à la console.
Écrivez une fonction qui permettra d'afficher le tableau d'étudiants à la console. La fonction reçoit un tableau de structures en paramètre et le nombre d'étudiants à afficher.

Exercice 6.8

Faite une copie de votre exercice 6.7 et supprimez la déclaration de la structure Etudiant. Ajoutez les déclarations des structures suivantes et modifiez votre programme de façon à utiliser ces nouvelles structures:

const int NbCours = 5;

struct Cours
{
    string NomCours;
    string NumeroCours;
    int NumSession;
    int Note;
};
 
struct Etudiant
{
    string Nom;
    string Prenom;
    string NumAdm;
    
    Cours Cours_Etudiant[NbCours];      // Les 5 cours que l'étudiant suit
};

De plus, modifiez la fonction d'affichage afin de calculer et d'afficher à la console la moyenne de chaque étudiant et de calculer et d'afficher la moyenne du groupe.

Exercice 6.9

Modifiez votre solution à l'exercice 3.9 de façon à utiliser la structure suivante:

struct Etudiant
{
	float Notes[3];
};

et le tableau suivant:

Etudiant TableauDesEtudiants[18];

Évidemment, le 3 et le 18 devront être remplacés par des constantes. Votre programme doit donc dans un premier temps lire les 3 notes des 18 étudiants, puis une fois les lectures terminées, calculer la moyenne de chaque étudiants et afficher le commentaire approprié.

Exercice 6.10

Modifiez votre solution à l'exercice 4.17 de façon à utiliser la structure suivante:

struct Etudiant
{
	int Numero;
	float Notes[3];
};

et le tableau suivant:

Etudiant TableauDesEtudiants[1000];

Évidemment, le 3 et le 1000 devront être remplacés par des constantes. Votre programme doit donc dans un premier temps lire le numéro et les 3 notes de tous les élèves jusqu'à ce que l'usager entre le numéro fictif égal à 999999, puis une fois les lectures terminées, calculer la moyenne de chaque élève et afficher le numéro de l'élève et sa moyenne. À la fin, le programme doit afficher la moyenne de la classe.

Exercice 6.11

Modifiez une solution de l'exercice 5.6 de façon à utiliser les structures suivantes:

struct Heure
{
    int Heures;
    int Minutes;
};



struct Date
{
   int JourDuMois;
   int JourDeLaSemaine;  // ou string si vous préférez conserver le jour sous la forme "lundi", "mardi", etc.
   int Mois; // ou string si vous préférez conserver le mois sous la forme "septembre", "octobre", etc.
   int Annee;
};


struct Temps
{
	Date DateActuelle;
    Heure HeureActuelle;
};

Portez attention aux paramètres des fonctions. Assurez-vous ne pas utiliser des variables hors de ces structures pour conserver les minutes, les heures, le jour du mois, le jour de la semaine, le mois et l'année.

Exercice 6.12

Ah! Que la neige neigera! Modifiez votre paysage magique de Noël (voir exercice 5.3) de façon à faire tomber cent petits flocons de neige. Vous devez pour ce faire créer une structure Point qui permet de stocker les coordonnées d'un flocon de neige:

struct Point
{
   int x;
   int y;
};

Créez ensuite un tableau de Points pour stocker la position de chacun des 100 flocons qui tomberont dans l'écran:

Point PositionDesFlocons[100];

Évidemment, le nombre 100 devra être remplacé par une constante. Ensuite, vous devez initialiser la position de chacun des flocons avec une valeur aléatoire à l'aide de la fonction rand. La fonction rand retourne une valeur aléatoire entre 0 et RAND_MAX. La valeur de RAND_MAX peut varier mais est toujours au moins 32767. Il vous faudra utiliser un modulo pour vous assurer que la valeur ne dépasse pas 799 en x et 599 en y. N'oubliez pas d'initialiser le générateur de nombre aléatoire au début de votre programme principal de la façon suivante:

srand(static_cast<unsigned int>(time(0)));

Les fonctions rand, srand et time se trouvent dans les librairies cstdlib et ctime.

Dans la boucle d'animation, vous devez afficher chacun des petits flocons de neige. Ensuite, vous devez déplacer vers le bas chacun des petits flocons. Si un flocon est parvenu au bas complétement de l'image, il doit retourner en haut de l'image. Pour réaliser cet exercice, utilisez le petit flocon de neige suivant:

Voici une capture d'écran du résultat:

Voici l'algorithme général de votre programme:

Déclarer le tableau Flocons[]
Créer la fenêtre
Charger les images en mémoire
Initialiser le tableau Flocons[] avec des valeurs aléatoires
Tant que l'animation n'est pas terminée
   Dessiner le fond
   Dessiner les 4 images
   Pour chaque flocon
      Dessiner le flocon à la position spécifiée dans Flocons[]
   Rafraichir la fenêtre
   Attendre un peu
   Pour chaque flocon
      Descendre le flocon d'un pixel
      Si le flocon est en bas
         Remettre le flocon en haut

Exercice 6.13

Pour cet exercice, vous devrez faire un programme qui affiche 50 flocons au hasard dans l'image et l'usager doit être en mesure de déplacer le bonhomme de neige avec les touches du clavier pour ramasser les flocons. Pour ce faire, vous devrez utiliser la fonction AttendreEvenement pour attendre que l'usager appuie sur une touche.

Pour vous faciliter le travail, vous devez diviser la fenêtre en 18 lignes et 18 colonnes de 32 pixels chacune en utilisant un tableau 2D. Votre programme doit obligatoirement utiliser les déclarations suivantes:

// Dans un .h:
enum Objet {Vide, Flocon};
const int NbFlocons = 50;
const int NbCases = 18; 
const int NbPixelsParCase = 32; 
const int TailleImage = NbCases * NbPixelsParCase;

struct Position
{
    int x;
    int y;
};

// Dans le main:
Objet Tableau[NbCases][NbCases];
Position Bonhomme;

On obtient donc un tableau en deux dimensions où chaque case contient soit du vide, soit un flocon. Au départ, il faut initialiser les cases à Vide pour indiquer que les cases sont vides. On place ensuite au hasard les 50 flocons en tirant une position au hasard et en mettant la valeur Flocon dans la case correspondante.

On affiche les flocons en parcourant tout le tableau et en affichant l'image du flocon au bon endroit dans la fenêtre seulement si la case n'est pas vide.

La position du bonhomme de neige pour sa part est conservée dans un variable séparée et cette position est modifiée en fonction de la touche appuyée. Le bonhomme de neige ramasse un flocon en écrivant Vide dans la case correspondante à la position du bonhomme de neige.

Le programme se termine lorsque l'usager appuie sur la touche ESC.

8.9

Voici l'algorithme général de votre programme:

Déclaration du tableau 2D de flocons
Initialiser le tableau de flocons 
Placer les 50 flocons au hasard dans le tableau 

Déclaration et initialisation de la position du bonhomme de neige

Créer la fenêtre
Charger les images en mémoire

Tant que la touche ESC n'est pas appuyée
   Dessiner le fond

   Dessiner les flocons
   Dessiner le bonhomme de neige

   Rafraichir la fenêtre

   Attendre Evenement
   Bouger le bonhomme de neige
   Effacer le flocon en dessous du bonhomme de neige

N.B.: Conservez la position du bonhomme de neige en cases (de 0 à 17) et non en pixels. Cela vous simplifiera grandement la vie. Pour afficher le bonhomme de neige, il vous suffira alors de multipler les positions en x et en y par NbPixelsParCase pour obtenir sa position dans la fenêtre en pixels...

Exercice 6.14

Créez une énumération contenant les mois de l'année. Créez également une fonction qui reçoit un mois (tel que défini dans l'énumération) et qui retourne le nombre de jours de ce mois (en ne tenant pas compte des années bisextiles). Une façon très efficace pour ce faire est d'utiliser un switch (n'oubliez pas qu'il est possible que plusieurs case mènent au même bloc de code!) Écrivez ensuite un court programme de test qui appelle votre fonction en lui passant différents mois.

Séparez le tout en un module (un .h et un .cpp) et le main dans un autre .cpp. L'énumération devrait être placée dans le .h.