// Surchage et redéfinition de fonction
class Base {
   virtual int f() { 1 .... }
 ...
}

class A : Base {
   int f() {  ...  }  // redéfinition de f
}


class A : Base {
   int f() {  ...  }  // redéfinition de f
   int f(int x) { ... }   // Surchage
}


--------------------
class A : Base {
   int f(int x) { ... } 

}

Base *bp = new A();
bp->f();   // 1
bp->f(3);  // Ne compile pas
----------------

class Base {
   int f() { 3 .... }     // Surcharge
   int f(int x) { 4 ... }
 ...
}

class A : Base {
   // A hérite de f() et f(int)
}

class A : Base {
   int f() { .... }  // Redéfintion 
}

A a;
a.f(3);   // Ne compile pas car A n'éhtite plus de f(int) 
          // car f() est reféfinie.


//  Entrées/Sorties

Classes spécifiques : flux (stream)
           Operateurs : >> et << 

#include <iostream>

Trois flux déjà :  cin cout et cerr
double f = 3.24
(cout << f) << endl;
cin >> f;


//  Espaces de noms

namespace M2finance {
   ....

}

namespace aa {
   int i;
   int jl
   cout << i;
}

i // Pas possible
cout << aa::i;

class A {
    static int f(int) { ... }
|

A::f(2);

namespace bb {
    int i;
    int k;
}

namespace aa {
    void f();
    class B {
      void f();
   }

   void B::f() { .... }
}

   void aa::B::f() { .... }

cout << aa::i << bb::i;

// Directive "using"
using aa::i;

cout << i << bb::i;


using namespace aa;
 

cout << i << bb::i;
cout << aa::i << bb::i;

using namespace bb;

cout << j << k;
cout << i;  // NON
cout << aa::i << bb::i;


//  Exceptions



// Héritage
class Base { 
    virtual void f() { i++... }
    int i;
}

class A : Base {
    void f() { i++, Base::i++ Base::f() }
    A() : i(27) {}  // Constructeur par défaut
    int i ;
}

Base *bp = new A();
cout << bp->i;   // Compile pas
bp->f();