Modèle de l’examen Intra (20 %)
Veuillez fermer, s’il y a lieu, votre cellulaire.
On ne corrige pas : les fichiers d’en-tête, les commentaires, le format d’affichage. Veuillez écrire lisiblement vos codes.
Dans les questions d’examens,
" Faites le nécessaire "
signifie :
- écrire les instructions OU
- écrire une (ou des) fonction(s) et ses (ou leurs) appels pour réaliser des tâches demandées
Toute documentation sur papier permise.
Ordinateurs personnels prohibés.
Calculatrice permise mais non nécessaire.
Veuillez répondre dans le cahier d’examen et remettre obligatoirement l’énoncé
Partie 1 : nouveautés de C++
Question 1)
template < class T >
bool estIdentique( T tableau1[], int n1, T tableau2[], int n2) { if (n1 != n2)
return false;
else
{ for (int i = 0 ; i < n1 ; i++)
if ( tableau1[i] != tableau2[i] ) return false;
return true;
} }
// instructions pour tester et afficher les résultats des tests cout << "Les tableaux age1 et age 2 sont-ils identiques?"
<< estIdentique(age1, 6, age2, 7) << endl;
cout << "Les tableaux age1 et age 3 sont-ils identiques?"
<< estIdentique(age1, 6, age3, 6) << endl;
cout << "Les tableaux sexe1 et sexe2 sont-ils identiques?"
<< estIdentique(sexe1, 5, sexe2, 5) << endl;
/* ici on peut écrire une fonction de type void équivalente à la fonction originale estIdentique ou bien à la fonction template estIdentique.
L’essentiel est que le résultat de la comparaison est transmis par référence */
template < class T >
void determiner( T tableau1[], int n1, T tableau2[], int n2, bool & estIdentique) { estIdentique = true;
if (n1 != n2)
estIdentique = false;
else
{ for (int i = 0 ; i < n1 ; i++)
if ( tableau1[i] != tableau2[i] ) { estIdentique = false;
break;
} }
}
Question 2) Version 1 :
template < class T >
bool estSymetrique( T tableau [], int n) { for (int i =0 ; i < n/2 ; i++ )
if ( tableau[i] != tableau[n-1- i]) return false;
return true;
}
Version 2 :
template < class T >
bool estSymetrique( T tableau [], int n) { for (int i = 0, j = n-1 ; i < j ; i++, j-- ) if ( tableau[i] != tableau[j])
return false;
return true;
}
// appels pour tester la symétrie de la chaîne ville et du tableau age.
cout << "La chaîne ville est-elle symétrique? " << estSymetrique(ville,5) << endl;
cout << "Le tableau age est-il symétrique?"<< estSymetrique(age,6) << endl;
Question 3)
Pour la gestion la plus simple des immeubles à vendre (au maximum 25), un courtier
- année de construction (un entier, exemple 1989) - type de l'immeuble : un caractère
'P' : résidence privée 'C' : immeuble commercial 'A' : immeuble d'autre type
- prix évalué par la ville : un réel (exemple 123456.75 $) 1) Écrire les déclarations d'un tableau dynamique des immeubles;
2) Écrire :
a) seulement l’en-tête d’une fonction permettant de lire le fichier
"Im.txt", de remplir le tableau dynamique des immeubles,
de compter et transmettre par référence le nombre exact d’immeubles lus;
b) un appel (une utilisation) approprié de cette fonction.
3) Écrire une fonction permettant d'afficher un seul immeuble;
Écrire une autre fonction portant le même nom qui permet d'afficher tous les immeubles d’un type donné.
Quelle est la nouveauté de C++ vs C dans ces deux écritures ?
Quel genre de fonctions membres d'une classe qui utilisent souvent cette nouveauté ?
4) Écrire une fonction et les appels de cette fonction pour afficher à l'écran le prix le plus élevé de chacun des types d'immeubles (3 réels à afficher).
Solution :
// définition de la structure Immeuble : struct Immeuble {
int annee;
char type;
double prix;
};
// déclaration d’un tableau dynamique imm d’au maximum 25 immeubles const int MAX_IMM=25;
Immeuble * imm =new Immeuble[MAX_IMM];
….
// écriture de l’en-tête …..
void lireRemplir (char* nomFichier, Immeuble imm[], int & nbImm);
// un appel (une utilisation) approprié de cette fonction.
int nbImm;
lireRemplir ("Im.txt", imm, nbImm);
// Écrire une fonction permettant d'afficher un seul immeuble;
void afficher (Immeuble unImm) {
cout << "annee de construction : " << unImm.annee << endl;
cout << " type de l’immeuble : " << unImm.type << endl;
cout << " prix evalue par la ville : " << unImm.prix << endl;
cout << endl;
}
// Écrire une autre fonction portant le même nom qui permet d'afficher tous les // immeubles d’un type donné.
void afficher (Immeuble imm[] , int nbImm, char unType) { for (int i=0; i< nbImm; i++) {
if ( imm[i].type == unType) afficher (imm[i]);
} }
Quelle est la nouveauté de C++ vs C dans ces deux écritures ? Surdéfinition (surcharge) de fonctions
Quel genre de fonctions membres d'une classe qui utilisent souvent cette nouveauté ?
Constructeurs
5) Écrire une fonction et les appels de cette fonction pour afficher à l'écran le prix le plus élevé de chacun des types d'immeubles (3 réels à afficher).
void afficher(Immeuble imm[] , int nbImm, char unType, char * message) { cout << "Le prix le plus eleve des "<< message << " est : ";
double prixPlusEleve =0.0;
for (int i=0; i< nbImm; i++) {
if ( imm[i].type == unType && imm[i].prix > prixPlusEleve ) prixPlusEleve = imm[i].prix;
}
if (prixPlusEleve > 0)
cout << prixPlusEleve << endl;
else
cout << " n’existe pas! (aucun immeuble de ce type) \n";
}
// Appels:
afficher(imm, nbImm, ′P′, "residences privees");
afficher(imm, nbImm, ′C′,"immeubles commercials");
afficher(imm, nbImm, ′A′,"autres residences");
Partie 2 : Introduction à la POO avec C++
Question 2.1) : réaliser la partie d’implémentation de la classe :
class Rectangle { private :
int longueur, largeur;
public :
Rectangle(int = 5, int = 3);
Rectangle (const Rectangle&);
void afficher(char *);
// fonction constante!
int surface() const { return longueur * largeur ; }
// surcharger l'opérateur < (plus petit selon la surface) bool operator < (const Rectangle & );
// surcharger l'opérateur l'addition. Pour cet exemple, la somme // de 2 rectangles est un rectangle avec la longueur qui est la // somme des 2 longueurs et la même chose pour la largeur Rectangle operator + (const Rectangle &);
// fonction amie
friend void afficher(const Rectangle & r, char * message) ;
// fonction amie permettant de surcharger l'opérateur * (produit de deux // rectangles selon la définition (pédagogique) semblable à l'addition friend Rectangle operator * (const Rectangle & r1,const Rectangle & r2) ; };
Solution : voir opera1.cpp sur le site Web du cours //Constructeur :
Rectangle::Rectangle(int longueur, int larg){
this->longueur = longueur ; this->largeur = larg;
}
//Constructeur de recopie:
Rectangle::Rectangle (const Rectangle & autre){
longueur = autre.longueur ; largeur = autre.largeur;
}
//Une fonction membre pour afficher les informations d’un rectangle:
void Rectangle::afficher(char * message){
cout<<message<<"["<<longueur<<","<<largeur<<"]"<<endl;
}
//Surcharge de l’opérateur < avec une fonction membre:
bool Rectangle::operator < (const Rectangle & autre){
return surface() < autre.surface();
}
//Surcharge de l’opérateur + avec une fonction membre:
Rectangle Rectangle::operator + (const Rectangle & autre){
Rectangle resultat ;
resultat.longueur = longueur + autre.longueur ; resultat.largeur = largeur + autre.largeur ; return resultat ;
}
//Une fonction amie pour afficher les informations d’un rectangle:
void afficher(const Rectangle & r, char * message){
cout<<message<<"["<<r.longueur<<","<<r.largeur<<"]"<<endl;
}
//Surcharge de l’opérateur * avec une fonction amie:
//Remarquez qu’on ne répète pas le mot clé friend lors de //l’implémentation de la fonction amie , et qu’on n’utilise //pas l’opérateur de résolution de portée :: car une
//fonction amie d’une classe n’est pas membre de celle-ci
Rectangle operator*(const Rectangle & r1,const Rectangle & r2) { Rectangle resultat ;
resultat.longueur = r1.longueur * r2.longueur ; resultat.largeur = r1.largeur * r2.largeur ;
return resultat ; }
Question 2.2)
Réalisez la classe TableauNotes permettant de manipuler un tableau des notes du cours IFT1166 :
class TableauNotes
{
private :
float * globale ; // tableau dynamique des notes globales (pas à l’intra H04) int MAX_ETUD ; // maximum d'éléments pour l'allocation dynamique int nbEtud ; // le nombre effectif d'éléments pour traiter le tableau
public : // quelques fonctions membres à définir (à réaliser)
// Constructeur à 3 paramètres :
// construire à partir d'un tableau existant en connaissant le nombre //maximum (MAXI) et le nombre effectif d'éléments (n).
TableauNotes ( float glob[], int MAXI, int n) ;
// déterminer l'indice de la meilleure note, l'indice de la note la //plus faible
void determiner(int & indiceMeilleure, int & indicePlusFaible);
etc . . . };
1) Écrire au complet (la définition) du constructeur à 3 paramètres et de la fonction membre determiner;
2) Réaliser un constructeur de recopie approprié de la classe TableauNotes.
3) Réaliser une fonction membre de la classe permettant d'afficher le contenu du tableau suivant le modèle (format non important) :
Voici les notes globales des etudiants du cours : 1) 85.6
2) 78.9 etc …
4) Soit les déclarations suivantes dans main() :
float glob[50] ={ 85.6, 78.9, 92.4, 67.8, 75.5, 58.4, 98.7, 96.3} ; int nbEtud = 8 ;
4.a) Écrire une instruction qui permet de construire un objet notes1 de la classe TableauNotes à partir du tableau glob et de nbEtud.
4.b) Écrire une instruction qui permet de construire un objet notes2 comme une copie de l’objet notes1 créé en 4.a).
4.c) Écrire des instructions appropriées pour afficher les contenus des tableaux associés aux objets notes1 et notes2 ainsi que la plus faible note et la meilleure note.
TableauNotes ::TableauNotes ( float glob[], int MAXI, int n){
nbEtud = n;
globale = new float[MAX_ETUD=MAXI];
for (int i = 0 ; i < nbEtud ; i++) globale[i] = glob[i];
}
void TableauNotes ::determiner(int & indiceMeilleure, int & indicePlusFaible)
{
indiceMeilleure = indicePlusFaible = 0;
for (int i = 1 ; i < nbEtud ; i++)
{ if (globale[i] < globale[indicePlusFaible]) indicePlusFaible = i;
if (globale[i] > globale[indiceMeilleure]) indiceMeilleure = i;
} }
Un constructeur de recopie approprié de la classe TableauNotes :
TableauNotes(const TableauNotes & autre) { nbEtud = autre.nbEtud;
globale = new float[MAX_ETUD=autre.MAX_ETUD];
for (int i = 0 ; i < nbEtud ; i++) globale[i] = autre.globale[i];
}
Une fonction membre de la classe permettant d'afficher le contenu du tableau :
void afficher(char * nom) {
cout << "Voici les notes globales du tableau " << nom << " des etudiants du cours :\n";
for (int i = 0 ; i < nbEtud ; i++)
cout << i+1 << ") " << globale[i] << endl;
}
5) Soit les déclarations suivantes dans main() :
float glob[50] ={ 85.6, 78.9, 92.4, 67.8, 75.5, 58.4, 98.7, 96.3} ; int nbEtud = 8 ;
4.a) Écrire une instruction qui permet de construire un objet notes1 de la classe TableauNotes à partir du tableau glob et de nbEtud.
Solution :
TableauNotes notes1(glob, 50, nbEtud);
4.b) Écrire une instruction qui permet de construire un objet notes2 comme une copie de l’objet notes1 créé en 4.a).
solution : TableauNotes notes2(notes1);
4.c) Écrire des instructions appropriées pour afficher les contenus des tableaux associés aux objets notes1 et notes2 ainsi que la plus faible note et la meilleure note (c’est la même pour notes2 qui est une copie de notes1)..
solution :
notes1.afficher("notes1");
notes2.afficher("notes2");
int indiceMeilleure, indicePlusFaible;
notes1.determiner(indiceMeilleure, indicePlusFaible);
cout << "La plus faible note : "
<< notes1.uneNote(indicePlusFaible) << endl;
cout << "La plus forte note : "
<< notes1.uneNote(indiceMeilleure) << endl;
