enum iterieren

FoxDie

keine ahnung dein compiler ist ziemlich sparsam mit der fehlerbeschreibung, aber ich frag mich was du da compilen willst ... das ist ein einfaches enum und es geht so wie es gehen soll das hier ist keine frage nach debuging etc. das ist eine frage ganz im sinne von "wie ist es realisierbar"

so schon versucht?

Types operator++(Type& v) // prefix ++
{
    switch(v)
    {
        case TYPE1: return v=TYPE2;
        case TYPE2: return v=TYPE3;
        case TYPE3: return v=TYPE1;
    }

    throw "böser fehler";
}

FoxDie

ja das würde sicherlich gehen aber nimm mal an es gibt ca. 10 enums mit insgesamt über 500 werten und bitte sagt mir jetzt nicht "das würde ich auslagern und zur initialisierung einlesen" ... das sind alles namehashs und die müssen von anfang an da sein ohne großartig zig klassen ableiten zu müssen.

das geht sicher noch n bissl eleganter, läuft aber letzten endes wahrscheinlich immer auf das gleiche raus. automagisch gehts leider ned.

http://www.ddj.com/cpp/184403955

FoxDie

oh käseschachtel das sieht gut aus, das könnte meine hintertür sein ich muss das nur noch durchlesen

Edit: Das ist ganz schön harter Tobac und selbst das beispiel lässt sich nicht compilen ... ich bin ziemlich verunsichert im bezug auf das ich das schaffe zu fixen

Th

Mit enum wird dein Vorhaben nicht funktionieren, selbst mit der Enum-Klasse müßtest du alle Variablen von Hand auflisten.
Nimm doch einfach ein statisches konstantes Array:

static const int types[] =
{
  0xC83A99CB,
  0xA430067C,
  0x80D1ACFF
};

Oder mußt du in deinem Programm einzeln auf die enum-Variablen 'TYPE1'... mit Namen zugreifen?
Dann könntest du dafür noch eine std::map verwenden...

FoxDie

ich hab es nun mit einer statischen map in enum kombination realisiert, läuft so auch super

Ausserdem kann ich einen Array nicht in der klassendefinition initialisieren sonst meckert mich mein compiler voll weil der glaub alles was in der Klassendefinition steht auf den Heap verweisst und das dürfte nicht gut für große Datenmengen sein

Th

Ein statisches Array ginge schon in einer Klasse, du mußt nur die Definition getrennt von der Deklaration in der Source-Datei angeben:

// .h
class X
{
  static const int array[100]; // Größe entsprechend anpassen
};

// .cpp
const int X::array[100] = // static darf nicht mehr angegeben werden
{
  0xC83A99CB,
  0xA430067C,
  0x80D1ACFF
  // ...
};

FoxDie

hmm dann empfehle mal was ist besser

z.B.

//.h

class xxx
{

public:
void xxx();

enum test:int {
TEST1 = 1,
TEST2,
TEST3
};

private:
static bool IsDefined;
static map<int, uint32> TestMap;

}

//.cpp
void xxx()
{
if(!IsDefined)
{
TestMap[TEST1] = 0xC83A99CB;
TestMap[TEST2] = 0xA430067C;
TestMap[TEST3] = 0x80D1ACFF;
XXX::IsDefined = true;
}
}

oder deine variante?
Ich möchte speicherschonenden Zugriff bieten und dafür bietet sich meiner meinung nach map an