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

Ich dachte mir das in etwa so:

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

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

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

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

Natürlich unter der Vorraussetzung, dass < und == gegeben ist

Cheers
Cyres

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.

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

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

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.

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

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?

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.

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

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?

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.