Examen C++ 2024 — 2025

1. Le sujet

📥 Télécharger l'énoncé · ↗ Énoncé en plein écran · ↗ Corrigé officiel

2. Notions mobilisées

3. Correction — Exercice 1 : passages de paramètres

Le programme principal :

void main() {
   int a = 1;
   int b = -2;
   int c = 0;
   ajouter(a, b, c);
   cout << "apres appel de ajouter" << endl;
   cout << "c = " << c << endl;
}

Cas a — passage par valeur

void ajouter(int a, int b, int c) { c = a + b; }

Sortie : apres appel de ajouter puis c = 0.

L'argument c de la fonction est une copie de la variable du main. La modification reste locale, le c du main n'est pas touché.

Cas b — passage par pointeur

void ajouter(int a, int b, int* c) { *c = a + b; }

Résultat : erreur de compilation. L'appel ajouter(a, b, c) transmet c comme int, alors que la fonction attend un int*. invalid conversion from int to int*.

Pour faire fonctionner ce cas, il aurait fallu écrire ajouter(a, b, &c);.

Cas c — passage par référence

void ajouter(int a, int b, int& c) { c = a + b; }

Sortie : apres appel de ajouter puis c = -1.

L'argument c est un alias sur la variable du main. Toute écriture dans la fonction modifie directement la variable d'origine. c = 1 + (-2) = -1.

4. Correction — Exercice 2 : classe Forme

class Forme {
   public:
      virtual void description(const string s) { cout << "Ceci est une forme."; }
      virtual const double aire() { }
   private:
      virtual double perimetre() const = 0;
};

5. Correction — Exercice 3 : compteur d'appels

class Point {
   private: short x, y;
   public:
      Point()  { cout << " ++ normal \n"; }
      ~Point() { cout << " -- normal \n"; }
};

Cas a — variable locale

void main() { Point p; }

Sortie :

++ normal
-- normal

Le constructeur est appelé à la création. Le destructeur est appelé à la fin du scope (fin de main), juste avant le retour du programme. Tout est affiché.

Cas b — allocation dynamique sans delete

void main() { Point* p = new Point(); }

Sortie :

++ normal

Le constructeur est appelé. Mais aucun delete n'est appelé : l'objet alloué sur le tas n'est jamais libéré. Le destructeur n'est jamais déclenché → memory leak et pas d'affichage de -- normal.

(Quand le programme se termine, l'OS récupère la mémoire mais les destructeurs des objets non libérés ne sont pas appelés.)

Cas c — allocation et libération explicite

void main() { Point* p = new Point(); delete p; }

Sortie :

++ normal
-- normal

Le constructeur s'exécute, puis delete p appelle explicitement le destructeur avant de libérer la mémoire. Comportement attendu et propre.

6. Correction — Exercice 4 : Point / PointCol

Énoncé long avec 10 questions de cours. Réponses synthétiques :

PointCol *pc2 = new Point(7, 6);   // faux

je suis un point
mes coordonnees sont : 3 5
je suis un point colore
mes coordonnees sont : 8 6
ma couleur est : 2
je suis un point colore
mes coordonnees sont : 8 6
ma couleur est : 5

7. Correction — Exercice 5 : diamant + templates

L'exo ajoute deux classes à la hiérarchie : PointForme (caractère pour la forme) et PointFormeCol (à la fois forme et couleur).

Q1 — Diagramme UML

La hiérarchie forme un diamant dont la pointe basse est PointFormeCol :

Q2 — Les .h des deux nouvelles classes

// pointforme.h
#ifndef POINTFORME_H_
#define POINTFORME_H_
#include "point.h"

class PointForme : virtual public Point {
   protected:
      char forme;
   public:
      PointForme(short abs, short ord, char f)
         : Point(abs, ord), forme{f} { }
      void decrire() override {
         cout << "je suis un point avec une forme\n";
         cout << "mes coordonnees : " << x << " " << y
              << " et ma forme : " << forme << "\n";
      }
};
#endif

// pointformecol.h
#ifndef POINTFORMECOL_H_
#define POINTFORMECOL_H_
#include "pointcol.h"
#include "pointforme.h"

class PointFormeCol : virtual public Point,
                      public PointForme,
                      public PointCol {
   public:
      PointFormeCol(short abs, short ord, char f, unsigned int cl)
         : Point(abs, ord),
           PointForme(abs, ord, f),
           PointCol(abs, ord, cl) { }
      void decrire() override {
         cout << "je suis un point colore avec une forme\n";
         cout << "mes coordonnees : " << x << " " << y << ", "
              << "ma couleur : " << color << ", "
              << "ma forme : " << forme << "\n";
      }
};
#endif

Q3 — main avec vector<Point*> et itérateur

#include "pointformecol.h"
#include <vector>

int main() {
   vector<Point*> LPs;
   vector<Point*>::iterator it;

   Point* p   = new Point(3, 5);
   Point* pc  = new PointCol(3, 5, 3);
   Point* pf  = new PointForme(5, 6, 'o');
   Point* pfc = new PointFormeCol(5, 6, 'x', 9);

   LPs.push_back(p);
   LPs.push_back(pc);
   LPs.push_back(pf);
   LPs.push_back(pfc);

   for (it = LPs.begin(); it != LPs.end(); ++it)
      (*it)->decrire();

   return 0;
}

Chaque objet appelle sa propre version de decrire() grâce au polymorphisme dynamique (les decrire() sont virtuelles dans Point). Le vector<Point*> conserve uniquement le type statique de base, mais le dispatch est résolu au runtime.

★ Stratégie générale pour ce format

• Lire d'abord le code avant de répondre aux questions. Souvent les questions explicitent ce qui ne va pas dans le code.
• Identifier les pièges classiques :
  • fonction virtuelle pure en private
  • delete oublié après new
  • cast implicite parent → enfant (interdit)
  • accès aux attributs privés depuis une fille
  • héritage multiple sans virtual → diamant
• Justifier chaque réponse. Une bonne réponse sans explication vaut moins qu'une réponse partielle bien justifiée.
• Connaître la règle de trois, la syntaxe des templates, les modes d'héritage : ça revient à chaque exam.
• Schéma UML : même approximatif, il aide à structurer la réponse sur les hiérarchies.