class Fred {
   public:
     ...
};
 
 #if 0
 
   // Without operator overloading:
   Fred add(const Fred& x, const Fred& y);
   Fred mul(const Fred& x, const Fred& y);
 
   Fred f(const Fred& a, const Fred& b, const Fred& c)
   {
     return add(add(mul(a,b), mul(b,c)), mul(c,a));    // Yuk...
   }
 
 #else
 
   // With operator overloading:
   Fred operator+ (const Fred& x, const Fred& y);
   Fred operator* (const Fred& x, const Fred& y);
 
   Fred f(const Fred& a, const Fred& b, const Fred& c)
   {
     return a*b + b*c + c*a;
   }
 
 #endif

class Array {
    public:
      int& operator[] (unsigned i);     // Certains n'aiment pas cette syntaxe
      // ...
};

inline int& Array::operator[] (unsigned i) // Certains n'aiment pas cette syntaxe
{
      // ...
}

int main()
{
    Array a;
    a[3] = 4;   // Le code utilisateur doit être facile à écrire et à comprendre...
    // ...
}

class Array {
   public:
      int& elem(unsigned i)        
      { 
          if (i > 99) 
              error(); 
          return data[i]; 
      }
   private:
      int data[100];
};

int main()
{
    Array a;
    a.elem(10) = 42;
    a.elem(12) += a.elem(13);
    // ...
}

class Array {
    public:
      int& operator[] (unsigned i) 
      { 
          if (i > 99) 
              error(); 
          return data[i]; 
      }
    private:
      int data[100];
};

int main()
{
    Array a;
    a[10] = 42;
    a[12] += a[13];
}

class Matrix {
   public:
      Matrix(unsigned rows, unsigned cols);
      double& operator() (unsigned row, unsigned col);
      double  operator() (unsigned row, unsigned col) const;
      ...
      ~Matrix();                                 // Destructeur
      Matrix(const Matrix& m);               // Constructeur de copie
      Matrix& operator= (const Matrix& m);   // Opérateur d'assignement
      ...
   private:
      unsigned rows_, cols_;
      double* data_;
};
 
inline Matrix::Matrix(unsigned rows, unsigned cols)
    : rows_ (rows)
    , cols_ (cols)
    //data_ <--initialized below (after the 'if/throw' statement)
{
    if (rows == 0 || cols == 0)
       throw BadIndex("Matrix constructor has 0 size");
    data_ = new double[rows * cols];
}
 
inline Matrix::~Matrix()
{
    delete[] data_;
}
 
inline double& Matrix::operator() (unsigned row, unsigned col)
{
    if (row >= rows_ || col >= cols_)
       throw BadIndex("Matrix subscript out of bounds");
    return data_[cols_*row + col];
}
 
inline double Matrix::operator() (unsigned row, unsigned col) const
{
    if (row >= rows_ || col >= cols_)
       throw BadIndex("const Matrix subscript out of bounds");
    return data_[cols_*row + col];
}

int main()
{
    Matrix m(10,10);
    m(5,8) = 106.15;
    std::cout << m(5,8);
    //...
}

class Number {
   public:
      Number& operator++ ();    // prefix ++
      Number  operator++ (int); // postfix ++
};

Number& Number::operator++ ()
{
   // ...
   return *this;
}
 
Number Number::operator++ (int)
{
   Number ans = *this;
   ++(*this);  // ou appeler simplement operator++()
   return ans;
}

class Number {
   public:
     Number& operator++ ();
     void    operator++ (int);
};
 
Number& Number::operator++ ()
{
   //...
   return *this;
}
 
void Number::operator++ (int)
{
   ++(*this);  // ou appeler simplement operator++()
}

 Number x = /* ... */;
 ++x;  // appel de Number::operator++(), c-a-d x.operator++()
 x++;  // appel de Number::operator++(int), c-a-d calls x.operator++(0)

 Number x = /* ... */;
 Number y = ++x;  // y sera le nouvelle valeur de x
 Number z = x++;  // z sera la nouvelle valeur de x

for (i = 0; i < 10; i++) ....

#include "Fred.hpp"    // Déclaration de la classe Fred

void userCode(Fred& x)
{
      x = x;    // Auto-affectation
}

void userCode(Fred& x, Fred& y)
{
      x = y;    // C'est une auto-affectation si &x == &y
}

int main()
{
    Fred z;
    userCode(z, z);

return 0;
}

class Wilma 
{ 
};

class Fred {
    public:
      Fred()                : p_(new Wilma())      { }
      Fred(const Fred& f)   : p_(new Wilma(*f.p_)) { }
     ~Fred()                { delete p_; }
      Fred& operator= (const Fred& f)
        {
          // Ce code n'est pas bon : il ne traite pas le cas de l'auto-affectation !
          delete p_;             // Ligne 1
          p_ = new Wilma(*f.p_);     // Ligne 2
          return *this;
        }
    private:
      Wilma* p_;
};

Fred& Fred::operator= (const Fred& f)
{
    if (this == &f) return *this;  // Traite correctement le cas de  l'auto-affectation

    // Ici se trouve le code normal de l'opérateur d'affectation...

    return *this;
}

Fred& Fred::operator= (const Fred& f)
{
    // Ce code traite correctement (même si c'est implicite) le cas de l'auto-affectation 
   Wilma* tmp = new Wilma(*f.p_); // Pas de problème si une exception était levée ici
   delete p_;
   p_ = tmp;
   return *this;
}