[C++] Datentypen fester Größe

Ich bin momentan dabei, eine Netzwerkanwendung zu schreiben, die dementsprechend überall gleichgroße Datentypen verwenden sollte. In C99 gibts zwar den Header stdint.h, in dem int8_t und Co definiert sind, aber offensichtlich scheinen den selbst nach 10 Jahren noch nicht alle Compiler zu kennen. Zumindest sagt mir das aktulle MS Visual Studio, dass es weder stdint.h, noch cstdint kennt. Mein aktueller Ansatz war folgender:

Code (c++):

#ifndef STDINT_H
#define STDINT_H
 
#include <climits>
 
// Definition of 8 bit types
#if UCHAR_MAX >= 255
typedef unsigned char uint8_t;
typedef signed char int8_t;
#elif USHRT_MAX >= 255
typedef unsigned short uint8_t;
typedef signed short int8_t;
#elif UINT_MAX >= 255
typedef unsigned int uint8_t;
typedef signed int int8_t;
#elif ULONG_MAX >= 255
typedef unsigned long uint8_t;
typedef signed long int8_t;
#endif
 
// Definition of 16 bit types
#if UCHAR_MAX >= 65535
typedef unsigned char uint16_t;
typedef signed char int16_t;
#elif USHRT_MAX >= 65535
typedef unsigned short uint16_t;
typedef signed short int16_t;
#elif UINT_MAX >= 65535
typedef unsigned int uint16_t;
typedef signed int int16_t;
#elif ULONG_MAX >= 65535
typedef unsigned long uint16_t;
typedef signed long int16_t;
#endif
 
// Definition of 32 bit types
#if UCHAR_MAX >= 4294967295
typedef unsigned char uint32_t;
typedef signed char int32_t;
#elif USHRT_MAX >= 4294967295
typedef unsigned short uint32_t;
typedef signed short int32_t;
#elif UINT_MAX >= 4294967295
typedef unsigned int uint32_t;
typedef signed int int32_t;
#elif ULONG_MAX >= 4294967295
typedef unsigned long uint32_t;
typedef signed long int32_t;
#endif
 
#endif STDINT_H

Nicht elegant, funktioniert nur auf Prozessoren, bei denen 1 Byte = 8 Bit richtig und garantiert nicht, dass man exakt die Größe hat, die man will, sondern nur, dass man den kleinstmöglichen Datentyp hat. Insgesamt unbefriedigend.

Kannst du dir die char-Checks nicht sparen, weil in der Sprachspezifikation steht, daß char immer 8 Bit lang ist?

Die Spezifikation sagt eben nicht, dass ein char genau 8 Bit haben muss, sondern nur, dass er die kleinste adressierbare Einheit ist. Auf exotischeren Maschinen können das auch mal 7, 9 oder 12 Bit sein.

Edit: zumindest nach meinen Informationen.

MSVC hat eigene exact-width Datentypen:

Code (C):

 
#ifdef _MSC_VER
    typedef __int8  int8_t;
    typedef __int16 int16_t;
    typedef __int32 int32_t;
    typedef __int64 int64_t;
    typedef unsigned __int8  uint8_t;
    typedef unsigned __int16 uint16_t;
    typedef unsigned __int32 uint32_t;
    typedef unsigned __int64 uint64_t;
#elif defined(HAVE_STDINT_H)
#   include <stdint.h>
#else // assume 32-bit system
    typedef char  int8_t;
    typedef short int16_t;
    typedef int   int32_t;
    typedef long  int64_t;
    typedef unsigned char  uint8_t;
    typedef unsigned short uint16_t;
    typedef unsigned int   uint32_t;
    typedef unsigned long  uint64_t;
#endif
 

Damit würde ich mich schon zufrieden geben.

MSVC ist übrigens nicht C99-konform.

Edit: Bezüglich der Größe eines chars: Der Standard definiert, dass ein char genau ein Byte groß ist (was Jesus_666 wahrscheinlich gemeint hat), aber wie groß ein Byte ist, ist natürlich implementationsabhängig.

Ganz ehrlich, was schreibst du für Software, die übers Netzwerk mit Architekturen ungewöhnlicher Bytebreite sprechen muß? Wenn du das nicht gerade als Teil der Anforderungsspezifikation hast, dann ist das unnötiger Aufwand. Für welche Plattformen schreibst du den Code (und wäre es nicht sinnvoller, die obskureren Architekturen als Sonderfall zu behandeln und für den Rest 8-bittige Bytes anzunehmen)?

Für den konkreten Fall reicht die Beschränkung auf 8 Bit = 1 Byte, aber mich würde einfach interessieren, ob es eine saubere Lösung gibt, die überall funktioniert, so wie es der Standard verlangt.

Kleines Update: ich bin über http://www.azillionmonkeys.com/qed/pstdint.h gestolpert. Verfolgt einen ähnlichen Ansatz, ist aber deutlich vollständiger.