Exercices complémentaires

Hello World*
1. Créer un projet sous un IDE
2. Dans la fonction main() utiliser la commande cout pour afficher dans la console « hello, word
»
3. Modifier le code existant pour utiliser une chaîne de caractère de type string contenant la
phrase à afficher.

Compteur*
Ecrire un petit programme qui compte de 0 à une valeur que l’utilisateur saisit. Une fois que la valeur
est atteinte, le comptage s’arrête et le programme affiche « STOP ». Utiliser d’abord une boucle for
puis une boucle while. 2. Modifier ce programme pour que le programme s’arrête à 10 lorsque
l’utilisateur saisit une valeur supérieure à 10.

Opérations*
Ecrire un programme qui demande à l’utilisateur de saisir deux entiers sur la console. 2. Le
programme demande ensuite à l’utilisateur de choisir l’opération qu’il souhaite réaliser : addition,
soustraction, multiplication, quotient, reste de la division. 3. Ecrire une fonction récursive qui calcule
le factoriel d’un nombre entier que l’utilisateur choisit.

Nombres premiers**
Ecrire un programme qui détermine si un nombre est premier ou non, s’il n’est pas premier il donne
un nombre qui le divise.

Nombres premiers (bis)

Dans cet exercice vous écrirez un programme C++ contenant les trois fonctions ainsi qu’un main()
permettant de tester les fonctions.
1) Ecrire une fonction sequence prenant comme paramètre un entier N et qui retourne u(N) défini
par :
U(0) = 3 ;
U(1)=2 ;
U(n)=n.u(n-1)+(n+1).u(n-2) + n pour tout n>1.
2) Ecrire une fonction bool isDivisible(int a, int b) qui permet de déterminer si un nombre a est
divisible par un nombre b. Ecrire une fonction isPrimeNumber qui détermine si un nombre est
premier
Pour rappel le symbole % permet d'obtenir le reste de la division entière.

PGCD**
Ecrire une fonction récursive qui calcule le plus grand diviseur de deux nombres entiers. Le PGCD est
le plus grand entier qui divise ces deux nombres simultanément.

Ecriture binaire**
Ecrire un programme permettant de saisir un nombre écrit en binaire ou bien en décimal et de
donner son autre écriture. Ce programme contient deux sous-programmes :
a) Une fonction récursive qui retourne la notation binaire d’un entier naturel. Par exemple : 25
(=1.24 + 1.23 + 0.22 + 0.21+1.20 ) -> 11001
b) Une fonction récursive qui retourne la notation décimale d’un nombre binaire. Par exemple :
11001 -> 25

Liste d’entiers **
Créer un projet

Ajouter deux nouveaux fichiers dans votre projet :

• dataManagement.h

dataManagement.cpp

Ajouter les #include nécessaires dans les différents fichiers du projet

Ajouter la définition de la fonction « displayIntergerList(int ListInteger[10]) » qui affiche sur la sortie

console le contenu d’un tableau de 10 entiers qui sont passés en paramètre de la fonction. Ne pas
oublier d’ajouter la déclaration de la fonction dans le fichier dataManagement.h.

Modifier le programme principal pour tester la fonction.

Modifier le programme pour utiliser la classe vector à la place du tableau de 10 entiers.

Ajouter la fonction « fillIntegerList(vector &list) » dans dataManagement.cpp dont l’objectif est de

saisir une liste d’entiers que l’utilisateur saisit sur la console.

Tester cette fonction en appelant dans votre fonction « main », d’abord la fonction « fillIntegerList »
puis « displayIntegerList ».

Ajouter deux nouveaux fichiers (un .cpp et un .h) dans votre projet. « bubbleSort.cpp » et «
bubbleSort.h »

Ajouter une fonction « bubblesSort(vector &list) qui prend en entrée un vecteur d’entiers et qui trie
cette liste selon la méthode du tri à bulle.

Ajouter deux nouveaux fichiers pour faire de même avec le tri par insertion.

Soda*
Dans Soda.cpp dans Soda.h
 Dans la fonction main()

Recopier le code ci-dessus et l’exécuter

Ajouter une fonction « takeASip » qui prend le volume bu en paramètre (celui-ci ne doit pas être
supérieur au volume restant

Dans la fonction main(), appeler cette fonction puis une nouvelle fois getVolume() ;

Student**
1. Ecrire la déclaration d’une classe « Student » prenant respectivement comme attributs et
méthodes :
a. Les attributs :
i. Nom et prénom (2 string),
ii. date de naissance (3 entiers),
iii. une liste de cours (vecteur de string)
iv. et une liste de Grade (vecteur de Grade),
b. Les méthodes :
i. Le constructeur permet l’initialisation des nom/prénom/date de naissance
de l’étudiant
ii. getAge() retourne l’âge de l’étudiant en prenant en compte la date du jour,
iii. getAverage() retourne la moyenne des notes de l’étudiant,
iv. setCourses affecte à un étudiant une liste de cours,
v. fillResults() permet à l’utilisateur de rentrer les notes d’un étudiant en
demandant pour chaque cours auquel assiste l’étudiant la note obtenue, et
remplie en parallèle la liste de Grade.
vi. display() affiche différentes informations sur l’étudiant
2. Ecrire la déclaration d’une classe « Grade »
a. Cours, note obtenue
b. Getters et setters, display
3. Implémenter les définitions des différentes fonctions (les compléter si besoin) pour que le
programme ci-après fonctionne.
 Sortie écran réalisée dans la fonction fillResult

Affichage réalisée
par la fonction
display() appliquée à
un étudiant

Code de Gray**
Un code de Gray permet d’encode les nombres binaires de manière à ce que seul un digit soit
modifié entre un nombre et le suivant.

Pour convertir un nombre binaire en son code de Gray, commencer à droite avec le dernier digit (soit
le nieme digit). Si le (n-1)ieme digit est 1, remplacer par (x-1), sinon ne rien changer. Continuer jusqu’au
premier digit qui est supposer rester le même puisque son voisin de gauche est nécessairement 0.

Integers Binary Gray code

0 0 0
1 1 1
2 10 11
3 11 10
4 100 110
5 101 111
6 110 101
7 111 100
8 1000 1100
9
10
11
12
13

1. Compléter les valeurs du tableau précédent

2. Ecrire l’algorithme d’un programme qui converti un nombre décimal entré par l’utilisateur en
son équivalent binaire et code Gray.
 3. Ecrire une classe Number, utiliser son constructeur pour affecter le nombre décimal. Créer
deux méthodes Bin et Gray qui fournissent respectivement la représentation binaire et de
Gray du nombre décimal. Appeler ses méthodes dans la fonction main().

Les polygones*

Ajouter au programme précédent une classe dérivée Rectangle et une fonction membre qui calcule
l’aire d’un rectangle. Ajouter dans la fonction main() le nécessaire pour tester cette fonction.

Modifier cette classe pour pouvoir utiliser la méthode area() sur un pointeur de Polygon
(polymorphisme).

Les polygones
Nous considérons la classe « Polygone » donnée ci-dessous :
 1) Ajouter dans la classe « Polygone » les définitions des accesseurs (méthodes « get » et
« set ») et de la méthode « affichage ». La méthode affichage indique le nombre de
côtés ainsi que la couleur du polygone.
2) Surcharger le constructeur de la classe Polygone pour que l’on puisse préciser le
nombre de côtés ainsi que la couleur lors de la création de l’objet.
3) Ecrire une classe dérivée « Triangle » de la classe « Polygone ». Rajouter des attributs
permettant de sauvegarder les longueurs. Faites en sorte qu’il ne soit pas possible de
modifier le nombre de côtés d’un objet de la classe Triangle (Pensez au masquage).
4) La méthode « affichage » de Triangle devra afficher en plus des informations de base
(nombre de côté et couleur) « la forme » de l’objet en question au moyen d’étoiles.
*
***
*****
5) Nous souhaitons ajouter une fonction (et non une méthode) qui affiche le
périmètre d’un triangle sans avoir à ajouter une nouvelle méthode à la classe triangle.
6) Ecrire la fonction principale qui :
a. Défini les objets suivants : un triangle vert, un polygone jaune, un triangle violet
b. Affiche les périmètres de ces objets
c. Regroupe tous ces objets dans le même conteneur,
d. Parcourir le conteneur et appeler pour chaque objet la méthode affichage.

Accumulator**
Déclarer une fonction nommée reset() qui prend un objet de la classe Accumulator et qui positionne
la valeur de la donnée membre de la classe loadValue à 0.Parce que reset() n’est pas membre de la
classe Accumulator, normalement reset() ne devrait pas avoir accès aux membres privés
d’Accumulator. Cependant, parce que Accumulator a spécialement déclarée cette fonction reset()
comme amie de la classe, la fonction reset() a accès aux membres privés d’Accumulator.

Nous noterons qu’ici nous avons passé en paramètre l’objet Accumulator à reset(). Ceci parce que
reset() n’est pas une fonction membre. Il n’a donc pas d’objet « accumulator » sur lequel il peut
exécuter des services, il est donc nécessaire de lui en donner un.

Vehicules**
Créer la classe suivante vehicle.

Ajouter passenger_load; comme une variable privée de la classe vehicle.

Créer une classe dérivée car qui hérite de la classe vehicle. Créer deux fonctions à l’intérieur de cette
classe :

initialize fonction qui initialise les différentes variables de la classe.

Passengers fonction qui retourne passenger_load.

Créer une classe dérivée truck qui hérite de la classe vehicle. Ajouter une variable privée : float
payload;

Créer trois fonctions dans cette classe dans le but d’exécuter la fonction main() suivante :

Matrice**

L'objectif de cet exercice est de calculer le produit d'une matrice par un vecteur en utilisant les
fonctions amies.
Créer les deux classes suivantes :

• l’une nommée vecteur, permettant de représenter des vecteurs à 3 composantes ; elle

comportera un constructeur et une fonction membre affiche.
• L’autre nommée matrice, permettant de représenter des matrices carrées de dimension 3x3;
elle comportera un constructeur avec un argument (tableau de 3x3 valeurs) qui initialisera la
matrice avec les valeurs et une fonction membre affiche.

1. Réaliser une fonction indépendante permettant de fournir le vecteur correspondant au

produit d’une matrice par un vecteur.
2. Réaliser une fonction membre à la classe vecteur permettant de fournir le vecteur
correspondant au produit d’une matrice par un vecteur.
3. Ecrire un programme de test.

System d’atterrissage d’urgence*

Dans le début des années 90, la NASA a introduit la fonctionnalité PCA Emergency Landing System.
PCA (Propulsion Controlled Aircraft) est un système de contrôle-moteur assisté par ordinateur qui
permet au pilote de poser un avion en toute sécurité lorsque les gouvernes (de direction, de
profondeurs ainsi que les ailerons) sont inactives. PCA a permis de rendre possible l'atterrissage
sécurisé d'un avion en utilisant uniquement la poussée de ses moteurs.

Le tableau ci-dessous montre les exigences en termes de calcul du système PCA. La majorité du code
est utilisé pour les contrôles de sécurité et de flexibilité pour le test en vol.
La question est : si nous voulons distribuer ce logiciel sur des ordinateurs de bord existants, nous
devons connaître la mémoire nécessaire. Nous considérerons ici la mémoire sous forme de "chunks",
il s'agit d'éléments permettant de stocker la mémoire par "morceaux".
Le tableau suivant montre les types de memory chuncks et leur capacité.
Memory type Size in bytes
A 100
B 25
C 10
D 5
E 1

Donc, par exemple, un logiciel de 1258 bytes nécessitera : 12 A, 2 B, 0 C, 1 D, et 3 E.

Questions
Vous créerez un nouveau programme qui comportera un main et les fonctions nécessaires. Votre
programme devra être bien structuré.
1) Ecrire une fonction permettant de déterminer pour une taille de bytes donnée la répartition des
memory chuncks nécessaires. Votre programme devra d'abord demander à l'utilisateur de saisir la
taille du logiciel en bytes. Il affichera ensuite le nombre de memory chunck nécessaire de chaque
type (A, B, C, D, E).
Attention, votre programme devra utiliser la plus grande quantité possible de la mémoire la plus
importante dans les mémoires non encore utilisées. C'est-à-dire qu'il n'est pas acceptable de
répondre dans l'exemple ci-dessus simplement "1258 E", mais qu'il est nécessaire de raisonner de la
manière suivante : le plus de A possible, puis le plus de B possible, ...
2) Enrichir votre programme pour qu'il demande maintenant 10 valeurs à l'utilisateur correspondant
à la taille en bytes de 10 logiciels. Votre programme devra présenter dans l'ordre croissant les
résultats. Vous utiliserez le tri par insertion pour organiser les données.
Robots***
La classe Robot modélise l'état et le comportement de robots virtuels. Chaque robot correspond à un
objet qui est une instance de cette classe.
Chaque robot :

• a un nom (attribut nom : chaîne de caractères),

• a une position : donnée par les attributs entiers x et y, sachant que x augmente en allant vers
l'Est et y augmente en allant vers le Nord,
• a une direction : donnée par l'attribut direction qui prend une des valeurs "Nord", "Est", "Sud" ou
"Ouest"
• peut avancer d'un pas en avant : avec la méthode sans paramètre avance()
• peut tourner à droite de 90° pour changer de direction (si sa direction était "Nord" elle devient
"Est", si c'était "Est" elle devient "Sud", etc.) : avec la méthode sans paramètre droite(). Les
robots ne peuvent pas tourner à gauche.
• peut afficher son état en détail

Le nom, la position et la direction d'un robot lui sont donnés au moment de sa création. Le nom est
obligatoire mais on peut ne pas spécifier la position et la direction, qui sont définis par défaut à (0,0)
et "Est".
1) Écrire les instructions en C++ qui permettent de définir la classe Robot, en respectant le principe
de l'encapsulation des données. Vous prendrez soin de bien structurer votre programme en séparant
chaque classe dans deux fichiers (le fichier d'entête ".h" et le fichier source ".cpp") et en faisant un
fichier séparé (".cpp") pour la fonction main().
Dans la fonction principale de l’application :

• Créer deux robots ;

• Afficher leurs caractéristiques ;
• Les faire avancer et tourner ;
• Afficher de nouveau leur caractéristique pour vérifier qu’ils sont bien à la position attendue.

2) On veut améliorer ces robots en créant une Nouvelle Génération, les RobotNG qui ne remplacent
pas les anciens robots mais peuvent cohabiter avec eux.
Les RobotNG savent faire la même chose mais aussi :

• avancer de plusieurs pas en une seule fois grâce à une méthode avance() qui prend en paramètre
le nombre de pas
• tourner à gauche de 90° grâce à la méthode gauche()
• faire demi-tour grâce à la méthode demiTour()
• La méthode afficher permet de savoir s’il s’agit d’un robot classique ou de nouvelle génération.

Écrire cette nouvelle classe en spécialisant celle de la première question, sans modifier celle-ci : Les
nouvelles méthodes changeront directement l'état de l'objet sans faire appel aux anciennes
méthodes (...mais attention aux droits d'accès !).
3) Dans le programme principal, on veut gérer ensemble dans un container de type Vector des objets
de type Robot et de type RobotNG. Après avoir créer plusieurs objets de chaque classe, afficher les
caractéristiques de chaque robot dans une boucle.

Les files d’attentes

Partie A : Introduction aux vector et itérateurs. Dans l’ensemble de cet exercice on utilisera les
utilisateurs pour parcourir les tableaux.

• Créer un tableau de 10 éléments avec « vector » et créer un itérateur qui permettra de

parcourir ce tableau.
• Remplir ce tableau avec des nombres aléatoires entre 1 et 20 en utilisant la fonction rand().
• Utiliser la fonction find() pour trouver s’il y a un nombre égal à 1 dans ce tableau.
• Créer une fonction qui prend le tableau de type « vector » comme argument d’entrée et qui
retourne un tableau de même type trié par ordre croissant en utilisant la fonction sort().

Pour information find() et sort() sont des méthodes de la bibliothèque algorithm et rand() est
une méthode de la bibliothèque math.

Partie B :
Un processus est un programme informatique qui est exécuté par un ordinateur. Un processus peut
demander à n'importe quel moment son exécution et a son propre temps d'exécution. Un
processeur est en charge d'exécuter ce processus. Même pour un système multi-processeurs, une
file d'attente se créera naturellement s'il y a plus de demandes que d'offres. Dans cet exercice nous
nous plaçons dans le contexte d'une file d'attente contenant 5 processus.

Processus Ordre d’arrivée Temps d’exécution Priorité

P1 4 2 2

P2 1 5 2

P3 3 3 1

P4 5 2 3

P5 2 4 4

Votre programme devra permettre de :

• Ordonnancer les processus en fonction de leur ordre d'arrivée (FIFO)

• Ordonnancer les processus en fonction de leur priorité
• Calculer le temps de séjour de chaque processus en fonction de l'ordre choisi
• Calculer le temps de séjour moyen en fonction de l'ordre choisi
Pour faire cela, vous vous servirez de vos connaissances en programmation objet et sur la classe
vector.