Contrôle périodique- Corrigé
Contrôle périodique- Corrigé
Programming, Math, etc. · exam
Voir tous les documents en programmationTous les examens en programmation
Fiche de révisionCorrigé
Rédigée à partir de ce document, puis vérifiée avant publication.
Ce contrôle périodique porte sur la programmation orientée objet en C++, avec un accent sur les concepts fondamentaux tels que l'encapsulation, l'héritage, la surcharge d'opérateurs, la programmation générique, ainsi que la gestion dynamique de la mémoire. Il évalue les compétences en conception de classes, implémentation de méthodes, et compréhension des mécanismes du langage C++.
Cet exercice teste la compréhension théorique des concepts fondamentaux de la programmation orientée objet en C++.
this est utile pour implémenter des fonctions pouvant être appelées en cascade, c'est-à-dire permettant d'enchaîner plusieurs appels sur le même objet.Fraction& Fraction::operator=(const Fraction& droite);Fraction& operator+=(Fraction& gauche, const Fraction& droite);L'implémentation d'un appel en cascade nécessite de retourner une référence vers l'objet courant.
Point& Point::incrementer()
{
x_++;
y_++;
return *this;
}
Cette méthode incrémente les attributs x_ et y_ puis retourne une référence à l'objet courant (*this) pour permettre l'appel en cascade.
Réponse finale : la méthode incrementer est correctement implémentée comme ci-dessus.
La déclaration d'une classe template nécessite de spécifier les paramètres de type pour chaque membre et attribut.
template <typename T1, typename T2, typename T3>
class Triplet
{
public:
Triplet(const T1& premier, const T2& deuxieme, const T3& troisieme);
T1 getPremier() const;
T2 getDeuxieme() const;
T3 getTroisieme() const;
void setPremier(const T1& premier);
void setDeuxieme(const T2& deuxieme);
void setTroisieme(const T3& troisieme);
private:
T1 premier_;
T2 deuxieme_;
T3 troisieme_;
};
Les méthodes permettent d'accéder et de modifier les trois valeurs stockées. Les types sont génériques et peuvent être différents.
Réponse finale : la classe est complétée comme ci-dessus.
La gestion manuelle de la mémoire dynamique au sein d'une classe nécessite la définition explicite de la forme de Coplien.
Base copierait les pointeurs vers les étudiants, ce qui ferait que deux objets Base partageraient les mêmes pointeurs vers les mêmes étudiants. Cela conduit à des problèmes de gestion mémoire et de double suppression.Etudiant ne serait pas libérée, causant une fuite mémoire.Base::~Base()
{
for (size_t i = 0; i < etudiants_.size(); i++) {
delete etudiants_[i];
}
}
Base& Base::operator=(const Base& base)
{
if (this != &base) {
// Libérer la mémoire existante
for (size_t i = 0; i < etudiants_.size(); i++) {
delete etudiants_[i];
}
etudiants_.clear();
// Copier les étudiants de base
for (size_t i = 0; i < base.etudiants_.size(); i++) {
int matricule = base.etudiants_[i]->getMatricule();
string nom = base.etudiants_[i]->getNom();
Etudiant* e = new Etudiant(matricule, nom);
etudiants_.push_back(e);
}
}
return *this;
}
bool Base::ajouterEtudiant(int matricule, string nom)
{
for (size_t i = 0; i < etudiants_.size(); i++) {
if (etudiants_[i]->getMatricule() == matricule) {
return false;
}
}
etudiants_.push_back(new Etudiant(matricule, nom));
return true;
}
string Base::getNomEtudiant(int matricule) const
{
for (size_t i = 0; i < etudiants_.size(); i++) {
if (etudiants_[i]->getMatricule() == matricule) {
return etudiants_[i]->getNom();
}
}
return "";
}
L'ordre d'exécution des constructeurs dépend de la hiérarchie d'héritage et de l'ordre d'initialisation des membres de classe.
B hérite de A. La classe C hérite de B et possède un attribut attrC_ de type B (composition).C ObjetC(10,20); produit l'affichage suivant :A(10)
B(20)
A()
B()
C(10,20)
La suppression efficace dans un tableau dynamique non ordonné s'effectue en remplaçant l'élément à supprimer par le dernier élément.
bool Base::retirerEtudiant(int matricule)
{
for (size_t i = 0; i < etudiants_.size(); i++) {
if (etudiants_[i]->getMatricule() == matricule) {
delete etudiants_[i];
etudiants_[i] = etudiants_[etudiants_.size() - 1];
etudiants_.pop_back();
return true;
}
}
return false;
}
Cette méthode supprime l'étudiant trouvé en libérant sa mémoire, remplace sa position dans le vecteur par le dernier élément, puis réduit la taille du vecteur.
Ce contrôle valorise la maîtrise des concepts fondamentaux de la programmation orientée objet en C++ :
Les erreurs les plus pénalisées sont :