enum MyEnum
{
	First,
	Second,
	Last
};

MyEnum GetMyEnum(bool flag)
{
	MyEnum myEnum = MyEnum::First;
	if (flag)
	{
		myEnum |= MyEnum::Second;
	}
	else
	{
		return myEnum;
	}
	return (myEnum | MyEnum::Last);
}

enum MyEnum
{
    First,
    Second,
    Last
};

MyEnum GetMyEnum(bool flag)
{
    int myEnum = MyEnum::First;
    if (flag)
    {
        myEnum |= MyEnum::Second;
    }
    else
    {
        return static_cast<MyEnum>(myEnum);
    }
    return static_cast<MyEnum>(myEnum | MyEnum::Last);
}

Mir würde es Bauchschmerzen bereiten. Weil jetzt der Rückgabetyp eine Wertemenge von drei Werten verspricht, Du aber sechs Werte in den Typ presst. Wer darüber switcht, wägt sich in falscher Sicherheit.
Du solltest mit einem int offen erklären "Hier stehe ich und rechne." Dann ist das auch ok.

In Fällen wie diesen, wo man es eher mit einer low-level-Variante eines Sets zu tun hat, ist int keine offensichtlich bessere Wahl. Es ist ja nicht so, als ob tatsächlich richtige Arithmetik damit betrieben würde. Man sollte evtl. über Operatorüberladung nachdenken.

constexpr MyEnum operator|(MyEnum lhs, MyEnum rhs) { return MyEnum( (unsigned)lhs | rhs ); }
MyEnum& operator|=(MyEnum& lhs, MyEnum rhs) { return lhs = lhs | rhs; }
// .. analog für & und ^

Mir würde es Bauchschmerzen bereiten. Weil jetzt der Rückgabetyp eine Wertemenge von drei Werten verspricht, Du aber sechs Werte in den Typ presst. Wer darüber switcht, wägt sich in falscher Sicherheit.
Du solltest mit einem int offen erklären "Hier stehe ich und rechne." Dann ist das auch ok.

Ok, ich fürchte mein geposteter Code war schwachsinn. Vielleicht sollte ich doch den ganzen Code posten. Die Funktion/Enum schaut so aus:

enum MyEnum
	{
		First = 1,
		Second = 2,
		Third = 0,
		Forth = 4,
		Fifth = 8
	};

MyEnum GetMyEnum()
{
	int myEnum = MyEnum::Third;
	if (Bedingung1)
	{
		myEnum |= MyEnum::First;
	}
	if (Bedingung2)
	{
		myEnum |= MyEnum::Second;
	}
	if (Bedingung3)
	{
		return static_cast<MyEnum>(myEnum);
	}
	return static_cast<MyEnum>(myEnum | MyEnum::Forth);
}

Macht der Code so immer noch Bauchschmerzen? Und kann mir mal jemand erklären was eigentlich diese |= Operation genau macht?

Macht der Code so immer noch Bauchschmerzen?

Die Werte-Verteilung in dem enum sieht auf jeden Fall sonderbar aus (besonders "Third=0")

Und kann mir mal jemand erklären was eigentlich diese |= Operation genau macht?

Der operator | liefert eine bitweise ODER-Verknüpfung der beteiligten Werte, |= ist der dazugehörige kombinierte Zuweisungsoperator ( a|=b ist äquivalent zu a=a|b ).

Weil jetzt der Rückgabetyp eine Wertemenge von drei Werten verspricht, Du aber sechs Werte in den Typ presst.

Ich verstehe die Aussage von volkard bzw. die Funktion der Funktion noch nicht so ganz. Kann der Rückgabewert also mehrere Werte gleichzeitig haben? Also mal angenommen die Bedingung1 ist wahr die anderen beiden falsch. Wäre im Rückgabetyp dann sowohl MyEnum::Third, MyEnum::First und MyEnum::Forth codiert?

volkard schrieb:

Weil jetzt der Rückgabetyp eine Wertemenge von drei Werten verspricht, Du aber sechs Werte in den Typ presst.

Ich verstehe die Aussage von volkard bzw. die Funktion der Funktion noch nicht so ganz. Kann der Rückgabewert also mehrere Werte gleichzeitig haben? Also mal angenommen die Bedingung1 ist wahr die anderen beiden falsch. Wäre im Rückgabetyp dann sowohl MyEnum::Third, MyEnum::First und MyEnum::Forth codiert?

Der Rückgabewert kann nur einen Wert annehmen, Du "veroderst" aber mehrere Werte in ihm, und das ist durch den definierten Typ gar nicht abgedeckt. Zum Beispiel baust Du aus "Forth | Fifth" arithmetisch den Wert 12, der aber in dem Enum gar nicht existiert. Du castest jetzt also 12 in den Enum - und das ist ganz einfach nicht korrekt.

Gruss, Knuttertron