Aufschalten einen Operator für beide Parameter in C ++ unter Verwendung const

Question

Ich versuche, eine überschriebene Operator-Funktion sowohl const Parameter zu erstellen, aber ich kann nicht herausfinden, wie es zu tun. Hier ist ein einfaches Beispiel:

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

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

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

    int value;
}

Was ich versuche, hier zu tun ist, in zwei Argumente in die Additionsfunktion übergeben, die beide const sind und das Ergebnis zurück, ohne etwas in der Klasse zu ändern:

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

Ist das möglich und wie würde ich mich dies zu tun?

Danke,

Dan

Answer 1

inline wird in Klassendeklarationen zu verstehen, so dass Sie es nicht angeben.

Die meisten idiomatisch, würden Sie einen Nicht-Member-Funktion außerhalb der Klassendefinition machen operator+ erklärt, wie folgt aus:

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

Sie müssen möglicherweise eine friend der Klasse machen, wenn sie den Zugang zu Number Interna muss.

Wenn Sie es als Mitglied Funktion haben müssen, dann müssen Sie die Funktion selbst const machen:

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

Für die Klassen wie Number wird operator+ typischerweise in Form von operator+= implementiert, wie Sie in der Regel alle wollen, dass die üblichen Operatoren wie erwartet funktionieren und operator+= ist in der Regel einfacher zu implementieren und operator+ neigt keine Effizienz zu verlieren über separat zu implementieren.

Innerhalb der Klasse:

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

Außerhalb der Klasse:

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

oder auch:

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

Wie wäre:

inline Number operator + (const Number& n) const

Answer 4

Während ich die bisherigen Antworten fühlen, sind gut genug, glaube ich, eine Klarstellung erforderlich ist.

Die Betreiber kommen (in der Regel) in zwei Geschmacksrichtungen

Die erste ist die Drittfunktionen ist, wobei das zweite die Elementfunktion, deren Parameter ist die „rechte Operand“ der Betrieb und die in der Regel gibt das aktuelle Objekt modifiziert.

Zum Beispiel vorstellen, es gibt ein Operator § für eine Klasse T. Es könnte geschrieben werden entweder als Nicht-Elementfunktion :

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

oder als Memberfunktion :

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

oder auch (sehr ungewöhnlich) als eine weitere Memberfunktion :

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

In der Regel sollten Sie die nicht-Member-Funktion bevorzugen, wenn auch nur, weil Sie es nicht Freund erklären. Somit kann unter Verwendung nicht-Mitglied nicht-friend-Funktion die Kapselung des Objekts verbessern.

Disclaimer:. Es gibt auch andere Aromen, aber ich beschränke mich Operatoren wie + Arithmetik, *, /, - etc. auch hier als "glaubwürdig" Operator Prototypen

Analysieren Sie Ihre Verwendung des Operators

Im Fall von +:

1. muss Jeder Operand konstant sein, weil a = b + c darf nicht b ändern, noch c.
2. Sie können +, wie in a = b + c + d + e ansammeln, so Provisorien muss vorhanden sein.

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

Im Fall von +=:

1. Sie kennen den linken Operanden A (von A + = B) geändert werden.
2. Sie kennen den linken Operanden A (von A + = B) sein eigenes Ergebnis ist.

So sollten Sie verwenden:

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

Wie immer vorzeitige Optimierung ist die Wurzel aller Übel

Ich habe diese Art von Code in der Produktion Code gesehen so, es hat geschehen:

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

Der Autor hoffte man vorübergehend zu sparen. Mit dieser Art von Code, a = b + c + d Schreiben führt zu interessanten (und falsch) Ergebnissen.

^ _ ^

Last but not least

Ich habe eine Liste der Betreiber Überlastung Prototypen auf Seite . Die Seite ist noch im Aufbau, aber seine Hauptanwendung (leicht funktionierende Prototypen zum Kopieren / Einfügen) kann sehr nützlich sein ...