ich habe z.B. folgendes enum

enum Types:uint32 
{
    TYPE1 = 0xC83A99CB,
    TYPE2 = 0xA430067C,
    TYPE3 = 0x80D1ACFF
};

das ganze ding befindet sich in einer statischen klasse.

nur leider müsste ich das enum iterieren und sämtliche werte abrufen die dort definiert sind (quasi for each).
Mein Bekannter meinte ja das dies nicht möglich wäre aber ich brauche ein werte feld welches während der compilierung initialisiert wird und seperierbar ist.

ich habe mitlerweile schon fast das enum aufgegeben weil einfach nichts funktioniert so wie ich es bräuchte.
hab operatoren versucht für das enum festzulegen ... ohne erfolg
hab versucht eine template klasse wie z.B. map drüberzulegen ... ohne erfolg
hab versucht zur laufzeit den enumtyp auf ein array umzulagern per calloc etc. ... ohne erfolg

mit struct + array geht es auch nicht da diese erst beim constructor aufruf initialisiert werden

vectoren ebenso glaube ich zumindest

gibt es noch eine andere möglichkeit? ich bin total fertig und hab 4 Stunden an den Problem gesessen

bevor ich es vergesse an den uint32 seht ihr bestimmt das es nicht sinnvoll ist hier einen max und min wert festzulegen.

enum Types:uint32

?SYNTAX ERROR

#ifndef uint32
#define uint32 unsigned long int
#endif

dachte ja net das einer das beispiel compilen will Oo

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

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

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

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

// .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
  // ...
};

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