In progress

README.md

@@ -8,4 +8,11 @@
 - [references.md](https://github.com/tony-maulaz/poo-exercices/blob/main/ex10-reference.md)
 
 ## Ex 20 - Stdout
-- [stdout.md](https://github.com/tony-maulaz/poo-exercices/blob/main/ex20-stdout.md)
+- [stdout.md](https://github.com/tony-maulaz/poo-exercices/blob/main/ex20-stdout.md)
+
+## Ex 30 - Surcharge
+- [surcharge.md](https://github.com/tony-maulaz/poo-exercices/blob/main/ex30-surcharge.md)
+
+## Ex 40 - Constructeur
+- [constructeur.md](https://github.com/tony-maulaz/poo-exercices/blob/main/ex40-constructeur.md)
+

ex40-constructeur.md

@@ -0,0 +1,174 @@
+## Ex 1
+
+Quel est l'affichage du programme suivant :
+
+```cpp
+class C1 {
+   public:
+    C1() { cout << "C1 est construit" << endl; }
+    ~C1() { cout << "C1 est détruit" << endl; }
+};
+
+class C2 {
+   public:
+    C2() { cout << "C2 est construit" << endl; }
+    C2(int a) { cout << "C2 avec param : " << a << endl; }
+    ~C2() { cout << "C2 est détruit" << endl; }
+
+    C1 c1[3];
+};
+
+void main(){
+    C2 c(3);
+}
+```
+
+## Ex 2
+
+Quel est l'affichage du programme suivant :
+
+```CPP
+class Point {
+   public:
+    Point() { cout << "Point construit" << endl; }
+
+    Point(const Point& p) { 
+        cout << "Point copié" << endl; 
+        this->value = p.value; 
+    }
+
+    ~Point() { cout << "Point détruit" << endl; }
+
+    int value;
+};
+
+int main()
+{
+    cout << "Ex 2 :" << endl;
+    Point p1;
+    p1.value = 5;
+    cout << "Décl P2" << endl;
+    Point p2;
+
+    cout << "P2 = P1"  << endl;
+    p2 = p1;
+
+    cout << "P3 = p1" << endl;
+    Point p3 = p1;
+    cout << "P4(p1)" << endl;
+    Point p4(p1);
+
+    p4.value = 6;
+
+    cout << "P1 val : " << p1.value << endl;
+    cout << "P2 val : " << p2.value << endl;
+    cout << "P3 val : " << p3.value << endl;
+    cout << "P4 val : " << p4.value << endl;
+}
+```
+
+## Ex 3
+Ajouter un constructeur et un destructeur dans la classe ci-dessous.
+
+Le constructeur permet d'initialiser les cordonnées lors de la création.
+
+Le destructeur permet d'afficher un message lorsque le point est détruit.
+
+```cpp
+#include <iostream>
+
+using namespace std;
+
+class Point{
+    public:
+
+        void plot(){
+            cout << "x : " << x << " - y : " << y << endl;
+        }
+        
+    private:
+        int x;
+        int y;
+};
+
+int main()
+{
+    cout<<"Exercice constructeur" << endl;
+
+    Point* p1 = new Point();
+    p1->plot();
+    delete p1;
+    cout << "fin de l'exercice";
+}
+```
+
+
+# Ex 4
+
+Ajouter des constructeurs afin que le code dans le `main` fonctionne, il doit initialiser les deux valeurs
+de mesures qui seront affichées par le programme.
+
+```cpp
+#include <iostream>
+
+using namespace std;
+
+class Measure{
+    public:
+        
+        string toString(){
+            return "val=" + to_string(value);
+        }
+        
+    private:
+        double value;
+};
+
+class Test{
+    public:
+
+        void plot(){
+            cout << "m1 : " << m1.toString() << endl;
+            cout << "m2 : " << m2.toString() << endl;
+        }
+
+    private:
+        Measure m1;
+        Measure m2;
+};
+
+int main()
+{
+    Test t(2.34, 12,8);
+    t.plot();
+}
+```
+
+## Ex 5
+
+Quel est l'affichage du code suivant ?
+
+```CPP
+struct A
+{
+    A() { cout << "Constr A" << endl; }
+    ~A() { cout << "Destr A" << endl; }
+};
+
+struct B: public A
+{
+    B() { cout << "Constr B" << endl; }
+    ~B() { cout << "Destr B" << endl; }
+};
+
+int main()
+{
+    cout << "Part 1" << endl;
+    A a;
+    cout << "Part 2" << endl;
+    B b;
+    cout << "Part 3" << endl;
+    p* p = new B();
+    delete p;
+}
+```

heritage.md

@@ -1,35 +1,64 @@
 ## Ex 1
 
-Est-ce que le programme ci-dessous est-correct ?
-Quel est l'affichage du programme ?
+Quelle est le comportement du programme ci-dessous ?
 
-```CPP
-class C1 {
-   public:
-    void afficher();
+```cpp
+#include <iostream>
+
+using namespace std;
 
-   protected:
+class C1 {
+  public:
+
+  protected:
     int val;
 };
 
-void C1::afficher() { cout << "Val : " << val << endl; }
+class C2 : public C1 {
+  public:
+    C2() { }
+};
+
+int main() {
+    C2 c;
+    c.val = 3;
+}
+```
+
+
+# Ex 2
+Quel est l'affichage du programme ci-dessous ?
+
+```cpp
+#include <iostream>
+
+using namespace std;
+
+class C1 {
+  public:
+    
+  public:
+    int val;
+};
 
 class C2 : public C1 {
-   public:
-    C2() { val = 4; }
+  public:
+    C2() { 
+        val = 5;
+    }
 };
 
-void ex1() {
+int main() {
     C2 c;
-    c.afficher();
-    c.val = 2;
-    c.afficher();
+    cout << "Res=" << c.val;
 }
 ```
 
+
 ## Ex 2
 
-Quel est l'affichage du programme suivant :
+Quel est l'affichage du programme suivant ?
+
 ```C++
 struct Parent{
     Parent(){
@@ -55,7 +84,7 @@ struct Enfant : public Parent{
     }
 };
 
-void ex2(){
+int main(){
     cout << "Exercice 2" << endl;
     cout << "E1" << endl;
     Enfant e1;
@@ -78,12 +107,12 @@ Implémenter les classes `Vehicule` et `Voiture` de l'image suivante :
 
 Le nombre de roue est affecté pendant la construction des classes enfants.
 
-Dans les méthodes, il faut juste afficher un texte.
+Dans les méthodes, il faut afficher un texte.
 
 Vous devez pouvoir exécuter le main suivant 
 
 ```CPP
-void ex3()
+int main()
 {
     cout << "Exercice 2" << endl << endl;
     Voiture v;

heritage_avance.md

@@ -1,28 +1,6 @@
 # Héritage avancé
 
-## Ex 1
 
-Quel est l'affichage du code suivant ?
-
-```CPP
-struct A
-{
-    A() { cout << "Constr A" << endl; }
-    ~A() { cout << "Destr A" << endl; }
-};
-
-struct B: public A
-{
-    B() { cout << "Constr B" << endl; }
-    ~B() { cout << "Destr B" << endl; }
-};
-
-void ex1()
-{
-    A* a = new B();
-    delete a;
-}
-```
 
 ## Ex 2