Operatoren mithilfe von Templates generieren, macht es Sinn?

Cyres

unskilled schrieb:

camper schrieb:

Cyres schrieb:

Macht es Sinn, Operatoren wie z.B. <=, != etc. mithilfe von Templates global zu überladen?

nein. Sobald du eine Klasse hast, die bereits Operatoren überlädt, riskierst du Mehrdeutigkeiten.

sinn ist es ja nicht, jede klasse davon abzuleiten.
ich habe etliche klassen so gebaut(nur < und == überladen) und dann erben lassen.
wenn man operatoren definiert, die in der basisklasse noch mal definiert werden, ist das halt an und für sich schon fail

Ich denke er meint eher Klassen allgemein, die schon Operatoren definiert und die Templates überschreiben dann vorher definierte andere Operatoren.

Was meinst du mit Ableiten, eine Oberklasse, die nur diese Operatoren anbietet und alle benötigten Klassen erben einfach davon? Auch ne gute Idee, und ein so schlechtes Klassendesign habe ich auch nicht, dass operatoren in derived-Klassen Überschrieben werden, kam mir jedenfalls bis Dato nicht unter - außer bei Komilitonen, aber die sind ja gerade außen vor

Kellerautomat

Mit boost.operators lassen sich Operatoren gezielt fuer eine Klasse generieren.

Sone

Kellerautomat schrieb:

Mit boost.operators lassen sich Operatoren gezielt fuer eine Klasse generieren.

Gibt auch einen Artikel darueber von pumuckl.
Darueber hinaus sei auch std::rel_ops nicht unerwaehnt.

Cyres

Danke für die zahlreichen Antworten, hat mir sehr geholfen

Cyres schrieb:

Hi,
...

template<class T, class U>
inline bool operator>(const T& lhs, const U& rhs)
{
	if (lhs < rhs)
		return false;
	return lhs != rhs;
}

Das ginge einfacher:

template<class T, class U>
inline bool operator>(const T& lhs, const U& rhs)
{
        return rhs < lhs;
}

daddy_felix

ich bins schrieb:

Das ginge einfacher:

template<class T, class U>
inline bool operator>(const T& lhs, const U& rhs)
{
        return rhs < lhs;
}

[/quote]

ähm... nein. Was ist bei Gleichheit?

Braunstein

ich bins schrieb:

Das ginge einfacher:

template<class T, class U>
inline bool operator>(const T& lhs, const U& rhs)
{
        return rhs < lhs;
}

Dieser Operator macht aber genau das Gegenteil vom Erwarteten.
Eher

template<class T, class U>
inline bool operator>(const T& lhs, const U& rhs)
{
        return !(rhs <= lhs);
}

wenn man schon > nicht direkt verwenden will.

camper

<(lhs,rhs)
>(lhs,rhs)  =>  rhs<lhs
<=(lhs,rhs) =>  !(rhs<lhs)
>=(lhs,rhs) =>  !(lhs<rhs)
==(lhs,rhs) =>  !(lhs<rhs)&&!(rhs<lhs)
!=(lhs,rhs) =>  !(lhs==rhs)  => (lhs<rhs)||(rhs<lhs)

Wenn nicht eine gewisse Symmetrie auftritt, ist wahrscheinlich ein Fehler gemacht worden.

Braunstein schrieb:

ich bins schrieb:
Das ginge einfacher:
template<class T, class U>
inline bool operator>(const T& lhs, const U& rhs)
{
        return rhs < lhs;
}
Dieser Operator macht aber genau das Gegenteil vom Erwarteten.
Eher
template<class T, class U>
inline bool operator>(const T& lhs, const U& rhs)
{
        return !(rhs <= lhs);
}
wenn man schon > nicht direkt verwenden will.

Also wenn lhs 17 und rhs 5 ist, dann ist 17>5 true und 5<17 auch true. 5<=17 ergibt true und damit !(5<=17) false.

Wenn A>B => B<A.

Oder nicht?

daddy_felix schrieb:

ich bins schrieb:

Das ginge einfacher:

template<class T, class U>
inline bool operator>(const T& lhs, const U& rhs)
{
        return rhs < lhs;
}

ähm... nein. Was ist bei Gleichheit?[/quote]

was soll dann sein?
lhs > rhs genau dann wenn rhs < lhs. alles gut so wie es ist.

Braunstein

Hast recht, ich hab nicht auf rhs und lhs geachtet.