C++ Operadores aritméticos


Ejemplo

Puedes sobrecargar todos los operadores aritméticos básicos:

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

La sobrecarga para todos los operadores es la misma. Desplácese hacia abajo para la explicación

Sobrecarga fuera de 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;
}

Sobrecarga dentro de 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: el operator+ debe devolver un valor no constante, ya que devolver una referencia no tendría sentido (devuelve un nuevo objeto) ni tampoco devolvería un valor const (por lo general, no debería devolver por const ). El primer argumento se pasa por valor, ¿por qué? Porque

  1. No puede modificar el objeto original ( Object foobar = foo + bar; no debería modificar foo después de todo, no tendría sentido)
  2. No puede hacer que sea const , porque tendrá que poder modificar el objeto (porque el operator+ se implementa en términos de operator+= , que modifica el objeto)

Pasar por const& sería una opción, pero luego tendrá que hacer una copia temporal del objeto pasado. Al pasar por valor, el compilador lo hace por ti.


operator+= devuelve una referencia al mismo, porque es posible encadenarlos (aunque no use la misma variable, sería un comportamiento indefinido debido a los puntos de secuencia).

El primer argumento es una referencia (queremos modificarlo), pero no const , porque entonces no podrías modificarlo. El segundo argumento no debe modificarse, por lo que, por razones de rendimiento, pasa por const& (pasar por const es más rápido que por valor).