Zum Thema 'sized integer types' hab ich grad folgende Passage bei MSDN entdeckt:

__int8 nSmall; // Declares 8-bit integer
__int16 nMedium; // Declares 16-bit integer
__int32 nLarge; // Declares 32-bit integer
__int64 nHuge; // Declares 64-bit integer

The types __int8, __int16, and __int32 are synonyms for the ANSI types that have the same size, and are useful for writing portable code that behaves identically across multiple platforms. Note that the __int8 data type is synonymous with type char, __int16 is synonymous with type short, and __int32 is synonymous with type int. The __int64 type has no ANSI equivalent.

Jetzt frag ich mich natuerlich was hinter __int64 steckt?
Koennte man __int64 evtl. mit long long vergleichen?
Ich waer naemlich an einem plattformunabhaengigen 64 bit integer interessiert!

Gruesse,
TS++

#if defined(_MSC_VER) && (_MSC_VER <= 1200) /* wenn MSVC und Version <= 6 */
 typedef unsigned __int64   ULONGLONG;
 typedef __int64            LONGLONG;
#else
 typedef unsigned long long ULONGLONG;
 typedef long long          LONGLONG;
#endif

siehe auch
http://www.c-plusplus.net/forum/viewtopic-var-t-is-109531.html

Ich waer naemlich an einem plattformunabhaengigen 64 bit integer interessiert!

Ob du es wirklich vollkommen plattformunabhängig hinbekommst, glaube ich kaum. Mit Sicherheit gibt es Plattformen und entsprechende Compiler, die einfach keinen 64 Bit Typ kennen. Dann kannst du dir nur selbst was basteln. Aber evtl. ist dieser Thread für dich interessant. Du fütterst einfach die Typliste mit allen möglichen zur Verfügung stehenden Typen und bekommst am Ende einen passenden Typen (oder auch nicht) mit entsprechender Bitgrösse und Vorzeichen.

Leider kommt schon mal der Borland-Compiler nicht damit zurecht:

E2489 Maximum option context replay depth exceeded; check for recursion at line 7

Das betrifft die folgende Zeile:

static const size_t result = compute_bits_per_byte<(Value >> 1), N + 1>::result;

Mir ist nochwas aufgefallen ( wahrscheinlich lieg ich aber mal wieder daneben! ):
Der ganze Ansatz basiert doch auf der Idee spezielle Templateimplementierungen durch Fallunterscheidung auszuwaehlen, oder? Implementiert wurde diese Fallunterscheidung mit der Annahme, dass der Compiler Nichtliterale in der Spezifikationsliste des Templates akzeptiert:

if_then_else< Size == bit_sizeof(typename Element::type), 
              Element, 
              select_type<Size, typename Element::next> 
            >::result tmp;

Hier steht ja offensichtlich ein "komplexer" boolscher Ausdruck innerhalb der spitzen Klammern. Ich hab bisher immer geglaubt, dass nur Literale zulaessig waeren!!!???
Lieg ich damit nun voellig falsch oder ist das in Deinem Fall nur ein Compilerspezifisches Feature?

Danke!

Gruesse,
TS++

Es muessen nicht zwangslaeufig Literale sein. Offensichtlich wird ein Aufruf von sizeof(...) als konstanter Ausdruck angesehen und die sind zulaessig.

Nur uebersetzen laesst sich der Code immernoch nicht!!!

Doch nicht die Loesung nach der ich gesucht hab!

Gruesse,
TS++

Hast du mal eine der anderen Lösungen versucht? So wie ich das sehe hat dein Compiler nur eine sehr geringe maximale Rekursionstiefe (vllt. kann man die in den Einstellungen irgendwo hochsetzen, musst du mal schauen). Konstante Ausdrücke kann ein Compiler schon zur Compiletime auswerten, für ein sizeof( Typ ) kann dein Compiler direkt die Größe in Bytes einsetzen und ein Konstante == Konstante kann er ebenfalls bereits zur Compiletime auf true und false auswerten.
Ob er das Komplement schon zur Compiletime auswerten können muss kann ich dir jetzt nicht sagen, aber die vorherigen Lösungsvorschläge berechnen die Anzahl der Bits nicht von Hand sondern verwenden eine Konstante aus climits, also versuch mal eine von denen

Leider kommt schon mal der Borland-Compiler nicht damit zurecht:

Kann sein, dass der Borland Compiler für Template Metaprogrammierung nicht besonders geeignet ist. Getestet wurde der Code jedenfalls mit einem aktuellen MSC und GCC.

TS++ schrieb:

E2489 Maximum option context replay depth exceeded; check for recursion at line 7

Das betrifft die folgende Zeile:

static const size_t result = compute_bits_per_byte<(Value >> 1), N + 1>::result;

Die Idee war eigentlich, solche "sized integer" Typen ohne jegliche externe Hilfsmittel zu bekommen. Die Bits pro Byte auszurechnen, ist eigentlich erst als letztes hinzugekommen. Wenn dein Compiler das nicht kann, dann kannst du auch das entsprechende Makro aus der stdlib nehmen.

// statt
#define bit_sizeof(x) (sizeof(x) * compute_bits_per_byte<~(unsigned char)(0), 0>::result)
// dann halt so
#define bit_sizeof(x) (sizeof(x) * CHAR_BIT) // <climits>

Ich werd's mal ausprobieren!

Gruesse,
TS++