Datentypen-Durcheinander

Hi, unter C# gibt es ja u. a. die Datentypen
Int16 -> short
Int32 -> int
Int64 -> long
UInt16 -> unsigned short
Uint32 -> unsigned int
UInt64 -> unsigned long

Wie würden die Datentypen nun äquivalent in C++ aussehen? So?

Int16 -> short
Int32 -> int
Int64 -> long long || long long int || _int64
UInt16 -> unsigned short
Uint32 -> unsigned int
UInt64 -> unsigned long long || unsigned long long int || unsigned _int64

wie ihr seht bin ich mir beim (U)Int64 unsicher was nun Mittel der Wahl ist.
Die Schreibweise sollte möglichst plattformunabhängig sein. Ginge z.B. auch folgendes unter Windows und Linux?

Int16 -> _int16
Int32 -> _int32
Int64 -> _int64
UInt16 -> unsigned _int16
Uint32 -> unsigned _int32
UInt64 -> unsigned _int64

Und warum hat man eigentlich int und long eingeführt wenn sie den gleichen Bereich abdecken?

pumuckl

Die Größe der eingebauten Integer-Datentypen in Bit ist unter C++ nicht festgelegt. es gibt nur Mindestgrößen und eine Ordnung, die besagt dass z.B. short mindestens so groß sein muss wie signed/unsigned char, int mindestens so groß wie short usw.
Wie groß die Typen dann wirklich sind, ist Sache des Compilerherstellers.
_int16 usw. sind keine Standard-Datentypen und daher nicht portabel.

In C99 gibts IIRC ein <stdint.h>, das int8_t, int16_t usw definiert. Für C++98/03 ist das aber kein Standard. Die Boost Libraries bieten aber einen Header <boost/cstdint.hpp> an, der diese Typen für viele Compiler portabel definiert.
In C++0x wird es dann auch <cstdint> geben, was eine Portierung des C-Headers ist.

314159265358979

Die Größe hängt von der jeweiligen CPU ab. So ist auf meinem 64 Bit Mac OS long 8 Byte groß und int 4 Byte. Wenn du exakte Größen haben möchtest, hast du im Header <cstdint> typedefs dafür:
int8_t - 1 Byte signed
int16_t - 2 Byte signed
int32_t - 3 Byte signed
int16_t - 4 Byte signed

Dann gibts die Typen noch mit einem 'u' vorne dran, also uint8_t, etc. Diese sind unsigned.

defaultplayer**

In C++ kann man sich nie sicher sein, wie groß eine Variable von einem Typ nun wirklich ist. Nach TCPPPL (Third Edition) gilt (4.6):
1 = sizeof(char) <= sizeof(short) <= sizeof(int) <= sizeof(long)
sizeof(N) = sizeof(signed N) = sizeof(unsigned N)
sizeof(char) >= 8 bits
sizeof(short) >= 16 bits
sizeof(long) >= 32 bits

Der Rest hängt wohl von der Plattform ab.

pumuckl

314159265358979 schrieb:

Die Größe hängt von der jeweiligen CPU ab.

Nur indirekt. Die Definition der Größe ist Sache des Compilerherstellers. Der wird sich auch in irgendeiner Weise an der Hardware orientieren, aber es können z.B. zwei verschiedene Compiler auf der selben CPU unterschiedliche Größen für short definieren.

314159265358979 schrieb:

Wenn du exakte Größen haben möchtest, hast du im Header <cstdint> typedefs dafür:
int8_t - 1 Byte signed
int16_t - 2 Byte signed
int32_t - 34 Byte signed
int1664_t - 48 Byte signed

Habs mal korrigiert.

Zu C++0x-<cstdint> ist noch zu sagen, dass die intXY_t und uintXY_t typedefs optional sind. Garantiert sind nur die int_leastXY_t, int_fastXY_t und die entsprechenden unsigned typen.

314159265358979

Ups. Das mit den 3 und 4 Byte ist mir jetzt aber peinlich. Sowas kommt, wenn man mit den Gedanken wo anders ist.

Danke euch soweit. Mir ging es allerdings weniger um die Größe, sondern um die plattformunabhängige Schreibweise. Hiernach http://msdn.microsoft.com/en-us/library/s3f49ktz%28v=vs.80%29.aspx gilt ja unter Windows:

C# -> C++ (Visual Studio)
Int16 -> _int16 -> short
Int32 -> _int32 -> int
Int64 -> _int64 -> long long
UInt16 -> unsigned _int16 -> unsigned short
Uint32 -> unsigned _int32 -> unsigned int
UInt64 -> unsigned _int64 -> unsigned long long

Die Frage ist nun ob die beiden Schreibweisen (Mitte und Rechts) plattformunabhängig sind, so dass die Sourcen auch unter Mac, Linux, Unix usw. compilieren? Ob ein int dann wiederum intern auf ein int_fast32_t oder ähnliches gemappt wird ist mit egal.

SeppJ

Was meinst du denn nun? Die Namen und die Größenverhältnisse rechts sind Plattformunabhängig. Aber nicht die exakten Größen, dazu müsstest du die Definitionen aus stdint.h oder einem anderen vergleichbaren Header (boost hat da glaube ich auch etwas dafür) nehmen oder gar zur Compilezeit (oder davor) prüfen was die Plattform bietet. Ist denn überhaupt wichtig bei deinem Programm wie die exakte Größe ist? Es ist ja doch eher selten, dass dies einen Unterschied macht.

Die genaue Größe ist mir letztendlich egal. Werde dann die Rechte Schreibweise verwenden.

hustbaer

Streng genommen ist long long noch kein Standardtyp. Alle (für mich) wichtigen Compiler unterstützen ihn aber. Und im neuen C++ Standard ist long long dann endlich auch dabei.

@StellerFragen:
Wenn du einen Typ suchst, der mindestens 32 Bit hat, aber auch mehr haben darf, dann kannst du long verwenden.

Was du z.B. nicht unbedingt machen solltest, ist int verwenden, wenn du mehr als 16 Bit brauchst. Weil int halt auch nur 16 Bit breit sein kann.

Die "minimalen Wertebereiche" der verschiedenen Typen findest du z.B. hier:

http://stackoverflow.com/questions/589575/size-of-int-long-etc/589684#589684

Wenn dir diese Garantien reichen, und du aufpasst immer den "passenden" Typ zu nehmen, dann kannst du natürlich mit char , short , int , long etc. arbeiten.