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

• myString + yourString pourrait servir à concaténer deux objets string
• myDate++ pourrait servir à incrémenter un objet Date
• a * b pourrait servir à multiplier deux objets Number
• a[i] pourrait donner accès à un élément contenu dans un objet Array
• x = *p pourrait déréférencer un"pointeur intelligent" qui "pointerait" en fait sur un enregistrement sur disque — le déréférencement irait chercher l'enregistrement sur le disque, le lirait, et le stockerait dans x.

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);
    //...
}

• L'approche operator() n'est jamais moins bonne car il est facile de l'implémenter en utilisant la représentation physique "matrice dense - stockage en ligne". Et donc dans les cas où cette représentation physique est la plus adaptée d'un point de vue performance, l'approche operator() est aussi facile à implémenter que l'approche operator[][] (il se pourrait même que l'approche operator() soit légèrement plus facile à implémenter, mais je ne vais pas pinailler).
• L'approche operator() s'avère parfois meilleure car à partir du moment où la représentation physique optimale n'est pas la représentation "matrice dense - stockage en ligne", il est le plus souvent sensiblement plus facile d'implémenter l'approche operator() que l'approche operator[][].

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 <assert.h>   // Succédané de gestion d'exceptions

typedef  int  bool;   // On aura bientôt plus besoin de ça

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

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

Number& Number::operator++ ()
{
   // ...
   return *this;
}
 
Number Number::operator++ (int)
{
   Number ans = *this;
   ++(*this);  // or 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++) ....