Enum-Größe * in der Praxis *

Für C++ vor 2011 besagt der Standard, dass Enums eine beliebige Größe haben können, von Byte bis lang. Aber in der Praxis scheint es, dass die meisten Compiler sie zu 4 Bytes machen.Enum-Größe * in der Praxis *

Also, in der Praxis irgendwelche vage aktuelle Compiler machen sie nicht ints?

Und ich muss klarstellen, dass ich nichts Seltsames mache, wie Enums> 2^31. Nur einfache enums. Und auf 32 oder 64 Bit Systemen läuft meine Software nicht auf 16 Bit!

Quelle

2016-05-18 Tuntable

'int' sein ist nicht unbedingt 4 Byte. – user657267

'enum/* class */MyEnum: unsigniertes Zeichen {...};'. Im C99-Compiler meldete einer meiner Kunden einen Fehler, der auf ein nicht verwandtes Modul überging, wobei die Größe von enum = Größe von UINT32 angenommen wurde. –

... und ein Byte ist nicht unbedingt 8 Bits. –

Wenn ein enum ist immer ein int, dann wäre die folgende unsicher sein:

enum oops { 
    foo = 32767, 
    bar, /*what am I?*/ 
};

Dies liegt daran, ein int so klein wie 16 Bit sein kann (und das ist immer noch überraschend häufig). Auf einem System mit einem 32 Bit int könnten Sie foo = 2147483647 setzen und Ihr Compiler sicherlich würde nicht wählen Sie einen int als zugrunde liegenden Typ.

So geben die cleveren C++ - BODs an, dass der zugrunde liegende enum Integraltyp in der Lage sein muss, die angegebenen Werte zu repräsentieren, und ein Compiler kann einen geeigneten auswählen. Angesichts der Tatsache, dass int oft als der native Typ der Maschine betrachtet wird, ist es oft eine vernünftige Wahl.

Wenn Sie den zugrunde liegenden Typ eines enum kennen möchten, dann bietet std::underlying_type dies.

Quelle

2016-05-18 07:40:09 Bathsheba

'und Ihr Compiler würde höchstwahrscheinlich keinen int als zugrunde liegenden Typ wählen. MSVC wählt' int', um 'long long' darzustellen, was zu einer Kürzung führt. Es * gibt * eine Warnung, aber ich persönlich glaube, dass es ein schwerer Fehler sein sollte. –

Sagen wir es auf jedem modernen Compiler sehen:

#include <iostream> 
#include <limits> 

enum MySmallSmall { 
    SmallValue = 0, 
}; 

enum MyLongLong { 
    LongValue = std::numeric_limits<long long>::max() 
}; 

int main() { 
    std::cout << "sizeof MySmallSmall is " << sizeof(MySmallSmall) << std::endl; 
    std::cout << "sizeof MyLongLong is " << sizeof(MyLongLong) << std::endl; 
    return 0; 
}

Klirren und g ++ Ausgabe:

sizeof MySmallSmall 4

sizeof MyLongLong ist 8

Aber für MS Visual Studio beide Ergebnisse sind 4 (Ich habe es mit diesem Sitz überprüft e http://rextester.com/l/cpp_online_compiler_visual nicht sicher, welche Compiler-Version ist hier)

So können Sie sich nicht auf sizeof einer enum verlassen.

Quelle

2016-05-18 07:49:40

Ich sehe nicht, wie diese Antwort etwas hinzufügt.In der Frage wurde bereits festgestellt, dass der zugrunde liegende Typ implementierungsdefiniert ist. –

Auch MSVC ist hier falsch. Der Maximalwert von 'long long' kann nicht in' int' passen, daher sollte er nicht einmal kompiliert werden. –

@SleepTightPupper die Frage war "Also, in der Praxis machen irgendwelche vage aktuellen Compiler sie nicht Ints?" ... Es gibt nur eine Möglichkeit, auf Praxisfrage zu beantworten, überprüfen Sie es. Und Sie haben Recht, dass MSVC nicht dem Standard folgt. Aber das ist ein Leben und Entwickler müssen sich daran anpassen. –

-3

Gnu ++ Compiler, können Sie es testen mit

#include <iostream> 

enum Tmp : unsigned long long int { 
    foo = 600000000000, 
    bar = 12, 
}; 


int main() { 
    Tmp lol; 
     std::cout << sizeof(lol) << " : " << Tmp::foo << " : " << sizeof(Tmp::foo) << std::endl; 
}

Antwort wird 8

Quelle

2016-05-18 07:59:27 pholat

Enum-Größe * in der Praxis *

Antwort

Verwandte Themen