enum class zu int

Hallo,

ich habe verschiedene enums die bestimmte Werte wie die Länge eines Wertes speichern. Jetzt muss ich oft irgendein int - den Wert des enums rechnen.
Momentan muss ich dabei immer mithilfe eines static_cast<int>(enum::wert) Compilerfehler vermeiden.

Gibt es eine Möglichkeit das einfacher zu machen? Habe hier über ein dutzend mal static_cast was einfach nicht schön aussieht.

Grüße

Nathan

Tricksen:

namespace foo
{
    enum foo
    {
        bar1,
        bar2,
        ...
    };
}

camper

enum class ist möglicherweise die falsche Wahl.
Eine Alternative wäre, die benötigten Operatoren zu überladen.

Make-Grafik

Wenn es nur um das Design des Codes geht, kannst du dir ja mal überlegen ob du nicht #define in betracht ziehst:

#include <iostream>

#define e(a) (static_cast<int>(a))

void main() {
	enum { A1, B2, C3 };
	int var = e(C3);

	std::cout << std::endl
			  << "  " << e(B2) << std::endl
			  << "  " << var << std::endl
			  << std::endl;

	system("pause");
}

Du willst allen Ernstes ein Makro namens e einführen? Ich seh da sehr lustige Compilerfehler auf dich zukommen, wenn in einer Template-Bibliothek irgendwo e als lokaler Bezeichner benutzt wird.

Mindestens willst du, dass das Ding Scopes respektiert, also eine Inline-Funktion. Folgendes wäre vertretbar:

namespace selber_namespace_in_dem_auch_die_enum_class_sitzt {
  inline int e(die_enum_class val) {
    return static_cast<int>(val);
  }
}

Da hat man ADNL echt gern. Ich würde mir aber trotzdem überlegen, einen etwas sinnvolleren Namen dafür zu wählen (oder gleich eine einfache enum zu benutzen).

Tachyon

Sowas?

#include <iostream>

enum class my_enum : int
{
	A,
	B,
	C
};

int operator-(int l, my_enum r)
{
	return l - static_cast<int>(r);
}

int main()
{
	int result = 10 - my_enum::B;
	std::cout << result << '\n';
}

so hab das jetzt so gelöst:

template <typename A, typename B>
int operator-(A, B)
{
	return static_cast<int>(A) - static_cast<int>(B);
}

template <typename C, typename D>
int operator+(C, D)
{	
	return static_cast<int>(C) + static_cast<int>(D);
}

template <typename E, typename F>
bool operator<(E, F)
{	
	return static_cast<int>(E) < static_cast<int>(F);
}

template <typename T>
inline int to_int(T)
{
	return static_cast<int>(T);
}

allerdings bekomme ich dabei compilerfehler:

error C2226: Syntaxfehler: Typ 'E' nicht erwartet
error C2144: Syntaxfehler: 'E' sollte auf '(' folgen
error C2226: Syntaxfehler: Typ 'A' nicht erwartet

und so weiter ... jemand ne ahnung was da falsch ist?

Nathan

Dein Code ist in etwa das ohne Templates:

int operator-(int, int)
{
    return static_cast<int>(int) - static_cast<int>(int);
}

Was wenig Sinn macht...
Wozu brauchst du überhaupt Templates?
Mache es doch einfach für deine Enum Class und gut ist.

das ist mir klar, ich habe aber mehrere enums (an die acht stück) und dann für jedes einzelnen enum die operatoren zu überladen - da erscheinen mir templates sinnvoller.

von daher wüsste ich gerne ob mir wer bei den syntaxfehlern helfen kann :>

Nathan

template <typename A, typename B>
int operator-(A, B)
{
    return static_cast<int>(A) - static_cast<int>(B);
}

Ist Schwachsinn.
Du musst Variablen der Typen erzeugen.

template <typename A, typename B>
int operator-(A a, B b)
{
    return static_cast<int>(a) - static_cast<int>(b);
}

*vor den kopf schlag* ähm, ja ... *wegduck*