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;
}