C++ Operatori aritmetici


Esempio

Puoi sovraccaricare tutti gli operatori aritmetici di base:

  • + e +=
  • - e -=
  • * e *=
  • / e /=
  • & e &=
  • | e |=
  • ^ e ^=
  • >> e >>=
  • << e <<=

Il sovraccarico per tutti gli operatori è lo stesso. Scorri verso il basso per la spiegazione

Sovraccarico al di fuori della class / struct :

//operator+ should be implemented in terms of operator+=
T operator+(T lhs, const T& rhs)
{
    lhs += rhs;
    return lhs;
}

T& operator+=(T& lhs, const T& rhs)
{
    //Perform addition
    return lhs;
}

Sovraccarico all'interno di class / struct :

//operator+ should be implemented in terms of operator+=
T operator+(const T& rhs)
{
    *this += rhs;
    return *this;
}

T& operator+=(const T& rhs)
{
    //Perform addition
    return *this;
}

Nota: l' operator+ dovrebbe tornare con un valore non const, in quanto restituire un riferimento non avrebbe senso (restituisce un nuovo oggetto) né restituirebbe un valore const (in genere non si dovrebbe restituirlo con const ). Il primo argomento è passato per valore, perché? Perché

  1. Non è possibile modificare l'oggetto originale ( Object foobar = foo + bar; non dovrebbe modificare foo dopo tutto, non avrebbe senso)
  2. Non puoi renderlo const , perché dovrai essere in grado di modificare l'oggetto (perché operator+ è implementato in termini di operator+= , che modifica l'oggetto)

Passare da const& sarebbe un'opzione, ma poi dovrai fare una copia temporanea dell'oggetto passato. Passando per valore, il compilatore lo fa per te.


operator+= restituisce un riferimento allo stesso, perché è quindi possibile incatenarli (non usare però la stessa variabile, sarebbe un comportamento indefinito a causa dei punti di sequenza).

Il primo argomento è un riferimento (vogliamo modificarlo), ma non const , perché non sarebbe possibile modificarlo. Il secondo argomento non dovrebbe essere modificato, e così per la ragione della prestazione viene passato da const& (passando per riferimento const è più veloce che per valore).