for (eMyType ..) wie typisierte Laufvariable inkrementieren?

[Espresso]

Hallo,

ich möchte in einer for-Schleife eine typisierte Variable - eType - inkrementieren,
wie geht das in C ?

for (eMyType eType = eMediumType; eType <= eLargeType; eType++) {
}

eType++ mag der Compiler nicht

Meldung des Compilers:
error C2676: Binärer Operator '++': 'eSmlType' definiert diesen Operator oder eine Konvertierung in einen für den vordefinierten Operator geeigneten Typ nicht


für sachdienliche Hinweise die zur Lösung der Frage führen ein großes Dankeschön,

Gruß Tom

[RHBaum]

typisierte Variable

in C++ sind alle variablen typisiert ^^

was genau ist eSmlType ?
eMyType ist wahrscheinlich nen typedef auf eSmlType ???

Falls eSmlType nen ENum ist -> Grundlagen. Warum haben enums keinen ++ operator ?

Ansonsten sagt der compiler ja scho ziemlich genau was IHM stört ...
eSmlType eSmlType ::operator++(eSmlType); gibts nicht, bzw kennt er nicht.
Fehlender Header oder (absichtlich ?) nicht implmentiert ... da koennen wir nur die Glaskugel interviewen ....

Ciao ...

[Espresso]

Hallo,
pardon, die Compiler-Meldungs-Zeile muss natürlich

eType ... heißen,

error C2676: Binärer Operator '++': 'eType' definiert diesen Operator oder eine Konvertierung in einen für den vordefinierten Operator geeigneten Typ nicht.

Eigentlich wollte ich hiermit fragen, wie eine typisierte Laufvariable, also eType inkrementiert werden kann,
oder wie man dies besser in C++ löst.

Der Compiler mischt klaglos in der for-Schleife die typisierte Variable und integer, was ich eigentlich vermeiden wollte.

Gruß Tom


Im Original:

enum eSmlType {
eMediumSml = 0,
eSmallSml = 1,
eLargeSml = 2,
eXlargeSml = 3 ,
eSmlType_LAST_ENTRY,
};

for (eSmlType eType = eMediumSml; eType <= eLargeSml; eType++) {

[RHBaum]

gar nicht, enums sind eben nicht incrementierbar ....

und das ist auch richtig so ...

was ist, wen du sowas hasst:

Enum EColor
{
eRed = 0xFF000000,
eGreen = 0x00FF0000,
...
};

Enums muessen nicht numerisch geordnet oder gar aufeinanderforgend sein.
(Warum kommt bei dir "small" nach "medium" und vor "large" ???)
Aus Performance-Gruenden kann der compiler auch nicht wissen(Listen führen) welche enum-werte es auch gibt.
Folglich kann der compiler nicht sicher inkrementieren !

Also Enums haben keinen ++ Operator.
Mit enums laesst sich auch nicht rechnen (+ operator)
Was enums haben, und wofuer sie ausschliesslich da sind, sind vergleiche (== !=).

was du machen kannst:
Schmutzige Version (weil du anforderungen an enums stellst, die nicht von enums abgedeckt werden ...

Code: Alles auswählen

for(int ix = eMediumSml; ix != eSmlType_LAST_ENTRY; ++ix) 
{
    eSmlType ex = reinterpret_cast<eSmlType >(ix);
}

Den ENum eliminieren:

Code: Alles auswählen

const int E_MEDIUM_SML = 0;
const int E_SMALL_SML = 0;
....
const int E_END_ENTRY = 0;

for(int ix = E_MEDIUM_SML; ix != E_END_ENTRY; ++ix) 
{
    
}

Oder, wahrscheinlich die sauberste variante:

Code: Alles auswählen

/// enum
enum eSmlType {
eMediumSml = 0,
eSmallSml = 1,
eLargeSml = 2,
eXlargeSml = 3
};
// Hilfsliste an performancetechnisch unbedenklicher stelle definieren und befuellen
std::list<eSmlType > lSMLTypes ; // im neuen C11++ Standard gibts da bessere alternativen, hier die klassische ... 
lSMLTypes.push_back(eMediumSml );
// ... 
lSMLTypes.push_back(eXlargeSml );

for(std::list<eSmlType >::const_iterator itx = lSMLTypes.begin(); itx != lSMLTypes.end(); ++itx)
{
     const eSmlType & ex = (*itx);
}

Ciao ....

[Espresso]

Hi,
recht vielen Dank für die ausführliche Antwort,

da werde ich die Hilfsliste in Zukunft verwenden, die wird es einfacher machen.

Gruß Tom