gibt es einen grund wieso:
-es kein logisches xor gibt?
-es kein ||= gibt?
-es kein &&= gibt?

und wenn ich gerade schon einen thread aufgemacht habe:
wie lasst ihr euch !=, <=, >, >= generieren wenn ihr == und < selbst definiert habt? gibt es da irgendwelche tricks? (auf makros habe ich persönlich wenig lust)

gruss

hallo

gibt es einen grund wieso:
-es kein logisches xor gibt?

Ich weiß nicht, ob dies der Grund ist, aber im Fall von bools macht ein != genau das gleiche. Wenn du keine bools hast, kannst du durch ein ! einen Ausdruck zu bool machen:

bool a,b;
if (a != b) //  a XOR B

int a,b;
if (!a != !b)  // a XOR B

-es kein ||= gibt?
-es kein &&= gibt?

Für bool machen &= und |= ohnehin schon das gleiche.

Allgemein: Wie soll denn da die Semantik sein?

int a = 1;
a ||= foo();

Wird foo aufgerufen oder nicht? Beide Möglichkeiten wären wohl verwirrend. Aufruf in jedem Fall wäre inkonsistent zum normalen ||. Aufruf nur bei Bedarf wäre verwirrend, weil die Schreibweise ziemlich danach aussieht, als würde es in jedem Fall aufgerufen.

Wenn die Operanden keine bools sind? Das wird wohl wirklich zu exotisch, um die Sprache damit voll zu müllen.

und wenn ich gerade schon einen thread aufgemacht habe:
wie lasst ihr euch !=, <=, >, >= generieren wenn ihr == und < selbst definiert habt? gibt es da irgendwelche tricks? (auf makros habe ich persönlich wenig lust)

Wenn man die paar Einzeiler nicht selber schreiben möchte, gibt es dafür was bei Boost (siehe Magazinartikel über Operatorüberladung). Da Boost auch nur mit Wasser kocht, kann man sich entsprechende Templates (keine Makros!) auch selber schreiben, wenn man unbedingt möchte.

P.S.:
http://www.c-plusplus.net/forum/240706
http://www.c-plusplus.net/forum/242944

asdfdasf schrieb:

hallo

gibt es einen grund wieso:
-es kein logisches xor gibt?

Ich weiß nicht, ob dies der Grund ist, aber im Fall von bools macht ein != genau das gleiche. Wenn du keine bools hast, kannst du durch ein ! einen Ausdruck zu bool machen:

bool a,b;
if (a != b) //  a XOR B

int a,b;
if (!a != !b)  // a XOR B

ups ja stimmt, einfach die operanden in bools konvertieren und auf ungleichheit prüfen...

SeppJ schrieb:

-es kein ||= gibt?
-es kein &&= gibt?

Für bool machen &= und |= ohnehin schon das gleiche.

Allgemein: Wie soll denn da die Semantik sein?

int a = 1;
a ||= foo();

Wird foo aufgerufen oder nicht? Beide Möglichkeiten wären wohl verwirrend. Aufruf in jedem Fall wäre inkonsistent zum normalen ||. Aufruf nur bei Bedarf wäre verwirrend, weil die Schreibweise ziemlich danach aussieht, als würde es in jedem Fall aufgerufen.

Wenn die Operanden keine bools sind? Das wird wohl wirklich zu exotisch, um die Sprache damit voll zu müllen.

man könnte einfach strikt sagen dass der ausdruck bei eingebauten typen zum ausdruck " lhs = lhs || rhs; " expandiert wird. soweit ich das sehe ist das dann auch für integrale typen und für bedingte aufrufe definiert (ich sage definiert, nicht intuitiv!). bei eigenen typen ist das überladen dieser operatoren (genau wie das überladen von && oder ||) speziell und die regeln werden komisch.
aber ja, ich weiss worauf du hinaus willst.
dann nehme ich die hand voll tastenanschläge eben einfach hin.

SeppJ schrieb:

und wenn ich gerade schon einen thread aufgemacht habe:
wie lasst ihr euch !=, <=, >, >= generieren wenn ihr == und < selbst definiert habt? gibt es da irgendwelche tricks? (auf makros habe ich persönlich wenig lust)

Wenn man die paar Einzeiler nicht selber schreiben möchte, gibt es dafür was bei Boost (siehe Magazinartikel über Operatorüberladung). Da Boost auch nur mit Wasser kocht, kann man sich entsprechende Templates (keine Makros!) auch selber schreiben, wenn man unbedingt möchte.

P.S.:
http://www.c-plusplus.net/forum/240706
http://www.c-plusplus.net/forum/242944

danke, so etwas habe ich gesucht.

gruss.

wie lasst ihr euch !=, <=, >, >= generieren wenn ihr == und < selbst definiert habt? gibt es da irgendwelche tricks? (auf makros habe ich persönlich wenig lust)

Manchmal reicht rel_ops aus dem Standard aus.

Manchmal reicht rel_ops aus dem Standard aus.

rel_ops ist so broken, dass man es unter keinen Umständen verwenden sollte.

ich implementiere gerade die paar wenigen operator-templates von boost nach die ich selbst brauche (so dass ich boost dafür nicht brauche da mein projekt selbst eine bibliothek werden soll). ich wollte nur kurz fragen, wie ich das hier machen soll:

namespace mg
{
	namespace Operators
	{
		// Requires:
		//   (Derived + Derived)
		//   Derived = Derived
		template<typename Derived, typename Chain = ::mg::EmptyBase>
		class MakeAddAssignable : public Chain
		{
		protected:
			MakeAddAssignable()
			{
			}
		public:
			Derived& operator+= (Derived const& Rhs)
			{
				*this = *this + Rhs; // hier
				return *this; // und hier
			}
		};

wie löst man das problem geschickt und elegant? this einfach nach Derived* casten?

gruss

class ...
{
   ...
   friend Ret op(Derived a, Derived b)
   {
     ...
   }
};

Sie werden dann problemlos vom Compiler gefunden.
Und normalerweise implementiert man operator$ mithilfe von operator$= und nicht umgekehrt.

Implementier die Operatoren so:

class ...
{
   ...
   friend Ret op(Derived a, Derived b)
   {
     ...
   }
};

Sie werden dann problemlos vom Compiler gefunden.
Und normalerweise implementiert man operator$ mithilfe von operator$= und nicht umgekehrt.

ja, das ist mir alles bewusst. es gibt aber ausnahmefälle wo es besser ist den operator$= mittels dem operator$ zu implementieren (auch in meiner lib gibt es solche). manuell sind diese zugehörigen $=-operatoren trivial zu implementieren, ich frage mich aber wie man das als operator-base lösen kann (siehe post oben).