class Fred
{
public:
    // ...
};
 
#if 0

    // Sans surcharge d'opérateur
    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));    // Hum...
    }
 
#else
 
    // Avec surcharge d'opérateur
    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_ est initialisé en suivant (après l'instruction 'if/throw')
{
    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 aura le nouvelle valeur de x
 Number z = x++;  // z aura 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 MaClasse
{
private :

    Ressource* ptr;

public :

    MaClasse& operator =(const MaClasse& Other)
    {
        // Destruction de ptr
        delete this->ptr;

        // Réallocation et affectation de ptr
        this->ptr = new int(*Other.ptr);

        return *this;
    }
};

MaClasse& MaClasse::operator =(const MaClasse& Other)
{
    if (this != &Other)
    {
        // Destruction de ptr
        delete this->ptr;

        // Réallocation et affectation de ptr
        this->ptr = new int(*Other.ptr);
    }

    return *this;
}

MaClasse& MaClasse::operator =(const MaClasse& Other)
{
    // ...
    return *this;
}

MaClasse& MaClasse::operator =(const MaClasse& Other)
{
    // Destruction de la ressource (ici un pointeur brut)
    delete this->Ressource;

    // Allocation d'une nouvelle
    this->Ressource = new ClasseRessouce;

    // Copie de la ressource
    *this->Ressource = *Other.Ressource;

    return *this;
}

MaClasse& MaClasse::operator =(const MaClasse& Other)
{
    // Réallocation de la ressource
    ClasseRessource* NouvelleRessource = new ClasseRessource(Other.Ressource);

    // Destruction de la ressource
    delete this->Ressource;

    // Réaffectation de la nouvelle
    this->Ressource = NouvelleRessource;

    return *this;
}

MaClasse& MaClasse::operator =(const MaClasse& Other)
{
    // Utilisation du constructeur par copie pour copier la ressource MaClasse
    MaClasse Temp(Other);

    // Réaffectation : on prend les nouvelles données dans Temp, et on lui
    // donne les données à détruire en échange
    std::swap(Temp.Ressource, this->Ressource);

    return *this;
} // A la fin de la fonction, Temp sera détruit automatiquement
  // et son destructeur désallouera correctement la ressource

// Le constructeur par copie
MaClasse::MaClasse(const MaClasse& Other)
{
    if (Other.Ressource)
        this->Ressource = new ClasseRessource(*Other.Ressource);
    else
        this->Ressource = NULL;
}

// Le destructeur
MaClasse::~MaClasse()
{
    delete this->Ressource;
}

class A
{
	A operator+(A const & second);
};

class A
{
};

A operator+(A const &first, A const &second);

A a1, a2;
a1 + a2; // Ok
a1 + 42; // Ok
42 + a2; // Ne compile pas

A a1, a2;
a1 + a2; // Ok
a1 + 42; // Ok
42 + a2; // Ok

class Double
{
public:
  Double(double d) : myValue(d) {}
  double val() {return myValue;}
private:
  double myValue;
};

bool operator== (Double const &d1, Double const &d2)
{
  static double const epsilon = 0.001;
  return d2.val() - d1.val() < epsilon;
}

Double a(0), b(0.0009), c(0.0011);
assert(a==b); // Ok
assert(b==c); // Ok
assert(a==c); // Erreur

class Personne
{
public:
  string nom;
  string prenom;
};

bool operator< (Personne const &p1, Personne const &p2)
{
  return p1.nom < p2.nom && p1.prenom < p2.prenom;
}

bool operator< (Personne const &p1, Personne const &p2)
{
  if (p1.nom < p2.nom)
    return true;
  else
    return p1.prenom < p2.prenom;
}

bool operator< (Personne const &p1, Personne const &p2)
{
  if (p1.nom < p2.nom)
    return true;
  else if (p2.nom < p1.nom)
    return false;
  else
    return p1.prenom < p2.prenom;
}