Operatoren mithilfe von Templates generieren, macht es Sinn?

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.