int i;

int moyenne(int i1, int i2);
float moyenne(float f1, float f2); //surcharge valide
float moyenne(int i1, int i2); //surcharge non valide

class Person
{
public:
    // accesseur : renvoie le nom
    const std::string & GetName() const // notez le const
    {
        return this->name;
    }

    // mutateur : change le nom
    void SetName( const std::string & NewName )
    {
        this->name = NewName;
    }

private:
    std::string name; // nom de la personne
};

#include "date.h" // classe permettant de stocker une date (pour l'exemple)

class Person
{
public:
    // age de la personne
    int GetAge() const;

private:
    // date de naissance
    Date  date_of_birth;
};

class Temperature
{
public:
    // degrés Celsius
    double GetCelsius() const
    {
        return this->temp_celsius;
    }
    void SetCelsius( double NewTemp )
    {
        this->temp_celsius = NewTemp;
    }

    // degrés Fahrenheit
    double GetFahrenheit() const
    {
        return ( ( this->temp_celsius * 9.0 ) / 5.0 ) + 32.0;
    }
    void SetFahrenheit( double NewTemp )
    {
        this->temp_celsius = ( NewTemp - 32.0 ) * 5.0 / 9.0;
    }

private:
    // en interne, on stocke en degrés Celsius
    double temp_celsius;
};

class Temperature
{
public:
    // degrés Celsius
    double GetCelsius() const
    {
        return ( this->temp_fahrenheit - 32.0 ) * 5.0 / 9.0;
    }
    void SetCelsius( double NewTemp )
    {        
        this->temp_fahrenheit = ( ( NewTemp * 9.0 ) / 5.0 ) + 32.0;
    }

    // degrés Fahrenheit
    double GetFahrenheit() const
    {
        return this->temp_fahrenheit;
    }
    void SetFahrenheit( double NewTemp )
    {
        this->temp_fahrenheit = NewTemp;
    }

private:
    // en interne, on stocke en degrés Fahrenheit
    double temp_fahrenheit;
};

class Stack {
   public:
      // ...
   private:
      LinkedList list_;
};

class Node 
{ 
   /*...*/ 
};

class LinkedList {
    public:
       // ...
    private:
       Node* first_;
};

void userCode(LinkedList& a)
{
    for (LinkedListIterator p = a.begin(); p != a.end(); ++p)
        cout << *p << '\n';
}

#include <cassert>   // Succédané de gestion d'exceptions

class LinkedListIterator;
class LinkedList;

class Node {
    // Pas de membres public; c'est une "classe privée"
    friend LinkedListIterator;  // Une classe amie 
    friend LinkedList;
    Node* next_;
    int elem_;
};

class LinkedListIterator {
   public:
      bool operator== (LinkedListIterator i) const;
      bool operator!= (LinkedListIterator i) const;
      void operator++ ();  // Aller à l'élément suivant
      int& operator*  ();  // Accéder à l'élément courant
   private:
      LinkedListIterator(Node* p);
      Node* p_;
};

class LinkedList {
   public:
      void append(int elem);   // Ajoute elem  après le dernier élément
      void prepend(int elem);  // Ajoute elem  avant le premier élément
      // ...
      LinkedListIterator begin();
      LinkedListIterator end();
      // ...
   private:
      Node* first_;
};

inline bool LinkedListIterator::operator== (LinkedListIterator i) const
{
      return p_ == i.p_;
}

inline bool LinkedListIterator::operator!= (LinkedListIterator i) const
{
      return p_ != i.p_;
}

inline void LinkedListIterator::operator++()
{
      assert(p_ != NULL);  // ou bien if (p_==NULL) throw ...
      p_ = p_->next_;
}

inline int& LinkedListIterator::operator*()
{
      assert(p_ != NULL);  // ou bien if (p_==NULL) throw ...
      return p_->elem_;
}

inline LinkedListIterator::LinkedListIterator(Node* p)
      : p_(p)
{ 
}

inline LinkedListIterator LinkedList::begin()
{
      return first_;
}

inline LinkedListIterator LinkedList::end()
{
      return NULL;
}

int op1(1);
double op2(2.1);
double result = op1 + op2; // polymorphisme de coercition

#include <iostream>

class CMyClass
{
public:
   operator bool()const
   {
      return true;
   }
};

int main()
{
   CMyClass a;
   std::cout<<std::boolalpha<< a<<std::endl;
   return 0;
}

void function(int);
void function(double);
void function(CMyClass);
// ...

template<class T>
void dump(T var)
{
   std::cout<<Timestamp()<<" : "<<var<<std::endl;
}

void function(IInterface const &var_)
{
   var_.Action();
}
class IInterface
{//...
};
class CConcrete : public IInterface
{//...
};

int main()
{
   CConcrete c;
   Fonction(c);
   return 0;
}

class Widget
{
  public:
  virtual ~Widget() { /* ... */ }
  void show()
  {
    // ...
    do_show();
    // ...
  }
  // ...

  private : 
    virtual void do_show()=0; // fonction virtuelle pure
};

class Button : public Widget
{
  private : 
    virtual void do_show() { std::cout << "Button" << std::endl; }
  // ...
};

class Textfield : public Widget
{
  private : 
    virtual void do_show() { std::cout << "Textfield" << std::endl; }
  // ...
};

void show_widget(Widget& w)
{
  w.show();
}

// ...

Button b;
Textfield t;

show_widget(b); // affiche "Button"
show_widget(t); // affiche "Textfield"

template <class Computation>
void do_something() 
{ 
  std::time_t start = time(NULL);
  Computation::compute();
  std::time_t end = time(NULL);
  std::cout << end - start << " seconds." << std::endl;
}

struct SingleThreadedComputation
{
  static void compute()
  { 
    // implémentation monothread
  }
};

struct MultiThreadedComputation
{
  static void compute()
  { 
    // implémentation multithread
  }
};

// par exemple :
#ifdef STCOMPUTATION
do_something<SingleThreadedComputation>();
#elif defined MTCOMPUTATION
do_something<MultiThreadedComputation>();
#endif

// comportement que l'on peut choisir soit avec un #define, 
// soit avec l'option de compilation -DSTCOMPUTATION ou -DMTCOMPUTATION

#ifdef OPTION1
  // code 1
#elif defined OPTION2
 // code 2
#elif defined OPTION3
  // code 3
#else
  // code 4
#endif

//interface de comportement pour baladeur (utilisant le pattern NVI)
class walkman_behaviour
{
  public:
    virtual
    ~walkman_behaviour(){}

    void
    click_back_button()
    {
      do_click_back_button();
    }

    void
    click_forward_button()
    {
      do_click_forward_button();
    }

  private:
    virtual
    void
    do_click_back_button() = 0;

    virtual
    void
    do_click_forward_button() = 0;
};

//collection de comportements pour baladeur
namespace walkman_behaviours
{
  class mp3_reader: public walkman_behaviour
  {
    public:
      void
      do_click_back_button()
      {
        //Lire chanson précédente...
      }

      void
      do_click_forward_button()
      {
        //Lire chanson suivante...
      }
  };

  class fm_tuner: public walkman_behaviour
  {
    public:
      void
      do_click_back_button()
      {
        //Passer à la fréquence précédente...
      }

      void
      do_click_forward_button()
      {
        //Passer à la fréquence suivante...
      }
  };
}

//baladeur audio
class walkman
{
  public:
    walkman(walkman_behaviour& c):
      behaviour_(&c)
    {
    }

    void
    behaviour(walkman_behaviour& c)
    {
      behaviour_ = &c;
    }

    void
    click_back_button()
    {
      comportement_->click_back_button();
    }

    void
    click_forward_button()
    {
      comportement_->click_forward_button();
    }

  private:
    walkman_behaviour* behaviour_;
};

int
main()
{
  walkman_behaviours::mp3_reader behave_mp3;
  walkman_behaviours::fm_tuner behave_fm;

  walkman b(behave_mp3); //comportement par défaut : lecteur mp3
  b.click_forward_button(); //lit la chanson suivante

  b.behaviour(behave_fm); //changement de comportement
  b.click_back_button(); //passe à la fréquence précédente

  return 0;
}