Rückgabeproblem mit Enum

Hi, wieso funktioniert denn in der GetMyEnum-Funktion die Return-Zeile und die |= Operation nicht?

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

EOutOfResources

Ein Integer kann nicht implizit in eine Enumator konvertiert werden.

Ist folgender Code eine gute Lösung oder eher nicht?

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

volkard

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.

camper

volkard schrieb:

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 ^

volkard schrieb:

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?

CStoll

Enumerator schrieb:

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 ).

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?

Enumerator schrieb:

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