Aufschalten einen Operator für beide Parameter in C ++ unter Verwendung const
-
03-07-2019 - |
Frage
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
Lösung
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;
}
Andere Tipps
class Number
{
Number()
{
value = 1;
};
inline Number operator + (const Number& n) const
{
Number result;
result = value + n.value;
return result;
}
int value;
}
Wie wäre:
inline Number operator + (const Number& n) const
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 +
:
- muss Jeder Operand konstant sein, weil
a = b + c
darf nichtb
ändern, nochc
. - Sie können
+
, wie ina = 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 +=
:
- Sie kennen den linken Operanden A (von A + = B) geändert werden.
- 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 ...