TP 2 - GR 2

Université Saint-Joseph
Faculté d’Ingénierie
ESIB
Génie Informatique et Communications
Semestre 1
Travaux Pratiques de Programmation Orientée Objets

Durée : 2h30 – Documents interdits
Indications :
1- Créer un git repo local pour versionner le code écrit
2- Créer le fichier “.gitignore” dans lequel vous mentionnez l’extension des fichiers à ignorer
(*.exe) en ajoutant les fichiers du répertoire courant à l’index.
3- Le code de chaque exercice sera écrit dans un fichier à part. Par exemple “main_ex1.cpp”.
4- Après avoir écrit et testé le code d’une partie dans un exercice, vous déposerez la version
courante dans l’index (git add main_ex1.cpp ) ou bien (git add .), puis dans le git repo en
mentionnant un message contenant le nom de l’exercice et de la partie. (git commit –m
“partie1”). Ensuite, vous renommer la fonction “main()” en incluant le numéro de la partie
travaillée et testée. (main_p1()). La nouvelle fonction “main()” contiendra le code de la
partie suivante.
Exercice 1 : Tableaux à la C++ (7 points)
Partie 1 : Création et affichage d’un « vector » (1 point)
Le but de cette partie est d’implémenter les fonctions « create » et « affiche ».
« create » prend un entier « n » et retourne un « vector » de « double » dont la taille est celle
spécifiée par l’entier « n ». Cette fonction demande à l’utilisateur de saisir la valeur de chaque case
de ce « vector ».
La fonction « affiche » prend un « vector » de « double » mais ne retourne rien. Elle affiche ce
« vector » conformément à l’affichage du « main » ci-dessous.
int main() {
vector<double> v = create(3);
cout << "v = ";
affiche(v);
Main
cout << endl;
return 0;
}
Entrez la valeur à l'indice 0: 10
Affichage
v = [ 10 30 50 ]
Bravo ! Maintenant, sachant que, dans le cadre de cet exercice, tous les « vector » sont des
« vector » de « double », dénotés par « vector<double> » ; simplifiez votre code en utilisant
« typedef » pour donner l’alias « List » à « vector<double> ».
Partie 2 : « Reverse » et « Concat » (2 points)
Dans cette partie, implémentez les fonctions « reverse » et « concat ».
La fonction « reverse » crée et retourne un « vector » qui contient les mêmes éléments du
« vector » passé en argument mais dans un ordre inversé : le premier élément devient le dernier et
le dernier devient le premier.
La fonction « concat » crée et retourne un « vector » qui contient tous les éléments des deux
« vector » passés en argument. Les éléments du premier argument sont d’abord placés puis ceux
du second argument sont placés après.
Main int main() {
2
List l1 = create(5);
cout << "l1 = ";
affiche(l1);
cout << endl;
List l2 = reverse(l1);
cout << "l2 = ";
affiche(l2);
cout << endl;
List l = concat(l1, l2);

cout << "l = ";
affiche(l);
cout << endl;
return 0;
}
Affichage
l1 = [ 10 20 30 40 50 ]
l2 = [ 50 40 30 20 10 ]
l = [ 10 20 30 40 50 50 40 30 20 10 ]
Partie 3 : Création et affichage multidimensionnel (2 points)
Utilisez maintenant « typedef » de façon à définir l’alias « ListVector » représentant un

« vector<List> » où « List » a été précédemment définit comme un « vector<double> ».
Implémentez une fonction « createListVector » qui prend un entier et retourne un « ListVector »

dont la taille est celle spécifiée l’entier passé en argument. Cet entier dénote, donc, le nombre
de « List » à créer. Notez qu’un « ListVector » n’est pas une matrice car chaque « List » de ce
vecteur peut avoir une taille différente. La fonction « createListVector » doit ainsi demander à
l’utilisateur de saisir la taille de chaque « List » ainsi que les valeurs de chacune de ces « List ».
La fonction « affiche » prend un « ListVector » et l’affiche selon le « main » ci-dessous.

int main() {
Main ListVector v = createListVector(3);
affiche(v);
3
}
On voudrait créer un vecteur composé de 3 vecteurs de double.
Saisissez la taille du vecteur numero 0 : 2
Affichage
[ 10 20 ]
[ 30 40 50 ]
[ 60 70 ]
Partie 4 : « reverse » et « flatten » d’un « ListVector » (2 points)
Implémentez une fonction « reverse » qui crée et retourne un « ListVector » contenant les mêmes
éléments du « ListVector » passé en argument mais dont l’ordre de chaque « List » sous-jacente a
été inversé comme montre le « main » ci-dessous.
Implémentez une fonction « flatten » qui crée et retourne une « List » contenant les mêmes
éléments du « ListVector » passé en argument dans l’ordre desquels elles ont été entrées dans la
fonction « createListVector » ; conformément au « main » ci-dessous.
Note : dans votre implémentation de « flatten », ne vous souciez pas des problèmes de
performance. C’est plutôt l’écriture d’un code lisible et maintenable qui est demandé.
int main() {
ListVector lv = createListVector(3);
affiche(lv);
cout << endl;
ListVector rlv = reverse(lv);

Main
affiche(rlv);
cout << endl;
List l = flatten(lv);
affiche(l);
cout << endl;
4
List rl = flatten(rlv);
affiche(rl);
cout << endl;
}
On voudrait créer un vecteur composé de 3 vecteurs de double.
Entrez la valeur à l'indice 0: 10.1
Affichage Entrez la valeur à l'indice 1: 70.7
[ 10.1 20.7 ]
[ 30.3 40.3 50.3 ]
[ 70 70.7 ]
[ 20.7 10.1 ]
[ 50.3 40.3 30.3 ]
[ 70.7 70 ]
[ 10.1 20.7 30.3 40.3 50.3 70 70.7 ]

[ 20.7 10.1 50.3 40.3 30.3 70.7 70 ]
5
Exercice 2 : The beauty of backward compatibility ! (8 points)
Le but de cet exercice est d’implémenter les mêmes fonctionnalités que l’exercice précédent, mais
en utilisant des « tableaux à la C ». L’utilisation de « vector » est donc interdite !
L’utilisation de « typedef » n’est pas demandée dans le cadre de cet exercice.
Partie 1 : Saisie et affichage (2 points)
Le but de cette partie est d’implémenter les fonctions « fill » et « affiche ».
« fill » prend un tableau de « double » et un entier « n » spécifiant la taille du tableau à la C passé

comme premier paramètre. Cette fonction ne retourne rien mais demande à l’utilisateur de saisir
la valeur de chaque case du tableau.
La fonction « affiche » prend un tableau de « double » et un entier « n » spécifiant la taille du

tableau à la C passé comme second paramètre. Elle ne retourne rien mais affiche un tableau
conformément à l’affichage du « main » ci-dessous.
int main() {
const int N = 5;
double v[N];
fill(v, N);
Main affiche(v, N);
cout << endl;
return 0;
}
Affichage
[ 10 20 30 40 50 ]
Partie 2 : « Reverse » et « Concat » (2 points)
Dans cette partie, implémentez les fonctions « reverse » et « concat » conformément au « main »
ci-dessous.
int main() {
const int N = 3;
Main
double l1[N];
fill(l1, N);
6
cout << "l1 = ";
affiche(l1, N);
cout << endl;
double l2[N];
reverse(l1, N, l2);
cout << "l2 = ";
affiche(l2, N);
cout << endl;
double l[N + N];

concat(l1, N, l2, N, l);
cout << "l = ";
affiche(l, 2 * N);
cout << endl;
return 0;
}
Affichage
l1 = [ 10 20 30 ]
l2 = [ 30 20 10 ]
l = [ 10 20 30 30 20 10 ]
Partie 3 : Création et affichage multidimensionnel (2 points)
Dans le cadre de cette partie, on va utiliser des tableaux multidimensionnels représentant des
matrices où le nombre de ligne est spécifié par l’utilisateur alors que le nombre de colonne est une
constante « C » globale égale à 3.
const int C = 3;
Implémentez la fonction « fill » et la fonction « affiche » selon le « main » ci-dessous.
int main() {
const int L = 3;
double v[L][C];
Main
fill(v, L);
affiche(v, L);
}
7
On voudrait créer une matrice composé de 3 lignes et de 3
colonnes
Saisissez la ligne numero 0 :
Affichage Entrez la valeur à l'indice 1: 50
[ 10 20 30 ]
[ 40 50 60 ]
[ 70 80 90 ]
Partie 4 : « reverse » et « flatten » d’un « ListVector » (2 points)
Implémentez une fonction « reverse » et « flatten » conformément au « main » ci-dessous.
Note : dans votre implémentation de « flatten », ne vous souciez pas des problèmes de
performance. C’est plutôt l’écriture d’un code lisible et maintenable qui est demandé.
int main() {
const int L = 3;
double lv [L][C];
fill(lv, L);
affiche(lv, L);
cout << endl;
double rlv[L][C];
Main
reverse(lv, L, rlv);
affiche(rlv, L);
cout << endl;
double l[L * C];

flatten(lv, L, l);
affiche(l, L * C);
cout << endl;
8
double rl[L * C];
flatten(rlv, L, rl);
affiche(rl, L * C);
cout << endl;
}
On voudrait créer une matrice composé de 3 lignes et de 3
colonnes
Affichage
[ 10 20 30 ]
[ 40 50 60 ]
[ 70 80 90 ]
[ 30 20 10 ]
[ 60 50 40 ]
[ 90 80 70 ]
[ 10 20 30 40 50 60 70 80 90 ]
[ 30 20 10 60 50 40 90 80 70 ]
9
Exercice 3 : Unique Value (5 points)
Complétez le fichier « unique_val.cpp » disponible sur Moodle.
Bon courage.
10

TP 2 - GR 2

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

TP 2 - GR 2

Transféré par

Droits d'auteur :

Formats disponibles

Université Saint-Joseph

Travaux Pratiques de Programmation Orientée Objets

Partie 1 : Création et affichage d’un « vector » (1 point)

Le but de cette partie est d’implémenter les fonctions « create » et « affiche ».

Partie 2 : « Reverse » et « Concat » (2 points)

Dans cette partie, implémentez les fonctions « reverse » et « concat ».

Main int main() {

List l = concat(l1, l2);

Partie 3 : Création et affichage multidimensionnel (2 points)

Utilisez maintenant « typedef » de façon à définir l’alias « ListVector » représentant un

Implémentez une fonction « createListVector » qui prend un entier et retourne un « ListVector »

La fonction « affiche » prend un « ListVector » et l’affiche selon le « main » ci-dessous.

Partie 4 : « reverse » et « flatten » d’un « ListVector » (2 points)

ListVector rlv = reverse(lv);

[ 10.1 20.7 30.3 40.3 50.3 70 70.7 ]

Partie 1 : Saisie et affichage (2 points)

Le but de cette partie est d’implémenter les fonctions « fill » et « affiche ».

« fill » prend un tableau de « double » et un entier « n » spécifiant la taille du tableau à la C passé

La fonction « affiche » prend un tableau de « double » et un entier « n » spécifiant la taille du

Partie 2 : « Reverse » et « Concat » (2 points)

double l[N + N];

Partie 3 : Création et affichage multidimensionnel (2 points)

Implémentez la fonction « fill » et la fonction « affiche » selon le « main » ci-dessous.

Partie 4 : « reverse » et « flatten » d’un « ListVector » (2 points)

Implémentez une fonction « reverse » et « flatten » conformément au « main » ci-dessous.

double l[L * C];

Vous aimerez peut-être aussi