Anular un operador usando const para ambos parámetros en C ++

Question

Estoy tratando de crear una función de operador anulada usando ambos parámetros const, pero no puedo entender cómo hacerlo. Aquí hay un ejemplo simple:

class Number
{
    Number()
    {
        value = 1;
    };

    inline Number operator + (const Number& n)
    {
        Number result;

        result.value = value + n.value;
        return result;
    }

    int value;
}

Lo que intento hacer aquí es pasar dos argumentos a la función de suma que son constantes y devuelven el resultado sin cambiar nada en la clase:

const Number a = Number();
const Number b = Number();
Number c = a + b;

¿Es esto posible y cómo haría para hacer esto?

Gracias,

Dan

Answer 1

inline se entiende en las declaraciones de clase, por lo que no necesita especificarlo.

Más idiomáticamente, haría que operator + sea una función no miembro declarada fuera de la definición de clase, así:

Number operator+( const Number& left, const Number& right );

Es posible que deba convertirlo en un amigo de la clase si necesita acceder a las partes internas de Number .

Si tiene que tenerlo como una función miembro, entonces necesita hacer que la función misma const:

Number operator+( const Number& n ) const
{ // ...

Para clases como Number , operator + generalmente se implementa en términos de operator + = ya que generalmente desea que todos los operadores habituales funcionen como se esperaba y operator + = suele ser más fácil de implementar y operator + tiende a no perder eficiencia por implementarlo por separado.

Dentro de la clase:

Number& operator+=( const Number& n );

Fuera de la clase:

Number operator+( const Number& left, const Number& right )
{
    return Number( left ) += right;
}

o incluso:

Number operator+( Number left, const Number& right )
{
    return left += right;
}

Answer 2

class Number
{
    Number()
    {
        value = 1;
    };

    inline Number operator + (const Number& n) const
    {
        Number result;

        result = value + n.value;
        return result;
    }

    int value;
}

Answer 3

¿Qué tal:

inline Number operator + (const Number& n) const

Answer 4

Si bien creo que las respuestas anteriores son lo suficientemente buenas, creo que se necesita alguna aclaración.

Los operadores vienen (generalmente) en dos sabores

La primera es la función no miembro, la segunda es la función miembro cuyo parámetro es el "operando correcto". de la operación y que generalmente devuelve el objeto modificado actual.

Por ejemplo, imagine que hay un operador § para una clase T . Podría escribirse como una función no miembro :

T operator § (const T & lhs, const T & rhs)
{
   T result ;
   // do the lhs § rhs operation, and puts the result into "result"
   return result ;
}

o como función miembro :

T & T::operator § (const T & rhs)
{
   // do the "this § rhs" operation, and puts the result into "this"
   return *this ;
}

o incluso (muy inusualmente) como otra función miembro :

T T::operator § (const T & rhs) const
{
   T result ;
   // do the "this § rhs" operation, and puts the result into "result"
   return result ;
}

Por lo general, debe preferir la función no miembro, aunque solo sea porque no debe declararla como amiga. Por lo tanto, el uso de la función no miembro no amigo mejora la encapsulación de su objeto.

Descargo de responsabilidad: hay otros sabores, pero me estoy limitando a operadores aritméticos como + , * , / , - , etc. aquí, así como también "creíble" prototipos de operador.

Analice su uso del operador

En el caso de + :

1. Cada operando debe ser constante porque a = b + c no debe cambiar b , ni c .
2. Puede acumular + , como en a = b + c + d + e , por lo que deben existir temporarios.

T & T::operator += (const T & rhs)
{
   // do the "this § rhs" operation, and puts the result into "this"
   return *this ;
}

En el caso de + = :

1. Usted sabe que el operando izquierdo A (de A + = B) será modificado.
2. Usted sabe que el operando izquierdo A (de A + = B) es su propio resultado.

Entonces deberías usar:

T & operator + (const T & lhs, const T & rhs)
{
   static T result ; // result is STATIC !!!!
   // do the lhs + rhs operation, and puts the result into "result"
   return result ;
}

Como siempre, la optimización prematura es la raíz de todo mal

He visto este tipo de código en el código de producción, así que sucede :

<*>

El autor esperaba economizar uno temporal. Con este tipo de código, escribir a = b + c + d genera resultados interesantes (e incorrectos).

^ _ ^

Por último, pero no menos importante

Escribí una lista de prototipos de sobrecarga de operadores en esta página . La página todavía está en construcción, pero su uso principal (prototipos de trabajo fáciles de copiar / pegar) puede ser bastante útil ...