it-swarm.com.de

Was ist der Unterschied zwischen einem int und einem long in C ++?

Korrigiere mich, wenn ich falsch liege,

int ist 4 Byte mit einem Wertebereich von -2.147.483.648 bis 2.147.483.647 (2 ^ 31)
lang ist 4 Byte mit einem Wertebereich von -2.147.483.648 bis 2.147.483.647 (2 ^ 31)

Was ist der Unterschied in C++? Können sie austauschbar verwendet werden?

111
Joel

Es ist implementierungsabhängig.

Unter Windows sind sie beispielsweise gleich, aber auf Alpha-Systemen war ein Long-Wert 64 Bit, während ein Int-Wert 32 Bit betrug. Dieser Artikel behandelt die Regeln für den Intel C++ - Compiler auf variablen Plattformen. Zusammenfassen:

  OS           Arch           size
Windows       IA-32        4 bytes
Windows       Intel 64     4 bytes
Windows       IA-64        4 bytes
Linux         IA-32        4 bytes
Linux         Intel 64     8 bytes
Linux         IA-64        8 bytes
Mac OS X      IA-32        4 bytes
Mac OS X      Intel 64     8 bytes  
101
Rob Walker

Die einzige Garantie, die Sie haben, sind:

sizeof(char) == 1
sizeof(char) <= sizeof(short) <= sizeof(int) <= sizeof(long) <= sizeof(long long)

// FROM @KTC. The C++ standard also has:
sizeof(signed char)   == 1
sizeof(unsigned char) == 1

// NOTE: These size are not specified explicitly in the standard.
//       They are implied by the minimum/maximum values that MUST be supported
//       for the type. These limits are defined in limits.h
sizeof(short)     * CHAR_BIT >= 16
sizeof(int)       * CHAR_BIT >= 16
sizeof(long)      * CHAR_BIT >= 32
sizeof(long long) * CHAR_BIT >= 64
CHAR_BIT         >= 8   // Number of bits in a byte

Siehe auch: Beträgt long garantiert mindestens 32 Bit?

78
Martin York

Beim Kompilieren für x64 liegt der Unterschied zwischen int und long zwischen 0 und 4 Byte, je nachdem, welchen Compiler Sie verwenden.

GCC verwendet das LP64-Modell. Dies bedeutet, dass Ints 32-Bit, Longs 64-Bit im 64-Bit-Modus sind.

MSVC verwendet zum Beispiel das LLP64-Modell, was bedeutet, dass sowohl Ints als auch Longs auch im 64-Bit-Modus 32-Bit sind.

13
Adrian

Die C++ - Spezifikation selbst (alte Version, aber gut genug dafür) lässt dies offen.

Es gibt vier vorzeichenbehaftete Ganzzahltypen: 'signed char', 'short int', 'int' und 'long int'. In dieser Liste bietet jeder Typ mindestens so viel Speicherplatz wie in der Liste davor. Einfache Ints haben die natürliche Größe, die von der Architektur der Ausführungsumgebung * vorgegeben wird.

[Fußnote: Das heißt, groß genug, um jeden Wert im Bereich von INT_MIN und INT_MAX zu enthalten, wie im Header <climits> Definiert. --- end foonote]

12
Kevin Haines

Wie Kevin Haines betont, haben ints die natürliche Größe, die von der Ausführungsumgebung vorgeschlagen wird und die in INT_MIN und INT_MAX passen muss.

Der C89-Standard besagt, dass UINT_MAX sollte mindestens 2 ^ 16-1 sein, USHRT_MAX 2 ^ 16-1 und ULONG_MAX 2 ^ 32-1. Das ergibt eine Bitanzahl von mindestens 16 für short und int und 32 für long. Für char heißt es ausdrücklich, dass es mindestens 8 Bits haben sollte (CHAR_BIT). C++ erbt diese Regeln für die Datei limits.h, daher gelten in C++ dieselben grundlegenden Anforderungen für diese Werte. Sie sollten jedoch nicht davon ableiten, dass int mindestens 2 Byte beträgt. Theoretisch könnten char, int und long alle 1 Byte sein, in welchem ​​Fall CHAR_BIT muss mindestens 32 sein. Denken Sie daran, dass "byte" immer die Größe eines Zeichens hat. Wenn char also größer ist, besteht ein Byte nicht mehr nur aus 8 Bits.

Es hängt von Ihrem Compiler ab. Sie haben die Garantie, dass ein Long mindestens so groß ist wie ein Int, aber Sie können nicht garantieren, dass es länger sein wird.

6
Andru Luvisi

Die Anzahl der Bytes und der Wertebereich werden größtenteils von der Architektur der CPU bestimmt, nicht von C++. In C++ sind jedoch Mindestanforderungen festgelegt, die in Litb richtig erklärt wurden und bei denen Martin York nur wenige Fehler gemacht hat.

Der Grund, warum Sie int und long nicht austauschbar verwenden können, ist, dass sie nicht immer dieselbe Länge haben. C wurde auf einem PDP-11 erfunden, wo ein Byte 8 Bits hatte, int zwei Bytes war und direkt durch Hardwareanweisungen behandelt werden konnte. Da C-Programmierer oft Vier-Byte-Arithmetik benötigten, wurde long erfunden, und es waren vier Bytes, die von Bibliotheksfunktionen verarbeitet wurden. Andere Maschinen hatten andere Spezifikationen. Der C-Standard stellte einige Mindestanforderungen.

5

Wenn Sie sich auf die Implementierung von primitiven Schriftgrößen durch den Compilerhersteller verlassen, werden Sie immer wieder auf die Idee kommen, wenn Sie Ihren Code auf einer anderen Rechnerarchitektur, einem anderen Betriebssystem oder einem Compiler eines anderen Herstellers kompilieren.

Die meisten Compiler-Anbieter stellen eine Header-Datei bereit, die primitive Typen mit expliziten Schriftgrößen definiert. Diese primitiven Typen sollten immer dann verwendet werden, wenn Code möglicherweise auf einen anderen Compiler portiert wird (lesen Sie dies in JEDER Instanz IMMER). Beispielsweise haben die meisten UNIX-Compiler int8_t uint8_t int16_t int32_t uint32_t. Microsoft hat INT8 UINT8 INT16 UINT16 INT32 UINT32. Ich bevorzuge Borland/CodeGear's int8 uint8 int16 uint16 int32 uint32. Diese Namen geben auch eine kleine Erinnerung an die Größe/den Bereich des beabsichtigten Wertes.

Seit Jahren benutze ich Borlands explizite primitive Typnamen und #include die folgende C/C++ - Header-Datei (primitive.h), die die expliziten primitiven Typen mit diesen Namen für jeden C/C++ - Compiler definieren soll (diese Header-Datei deckt möglicherweise nicht jeden Compiler ab, sondern mehrere Compiler, die ich verwendet habe Unter Windows, UNIX und Linux werden (noch) keine 64-Bit-Typen definiert.

#ifndef primitiveH
#define primitiveH
// Header file primitive.h
// Primitive types
// For C and/or C++
// This header file is intended to define a set of primitive types
// that will always be the same number bytes on any operating operating systems
// and/or for several popular C/C++ compiler vendors.
// Currently the type definitions cover:
// Windows (16 or 32 bit)
// Linux
// UNIX (HP/US, Solaris)
// And the following compiler vendors
// Microsoft, Borland/Imprise/CodeGear, SunStudio,  HP/UX
// (maybe GNU C/C++)
// This does not currently include 64bit primitives.
#define float64 double
#define float32 float
// Some old C++ compilers didn't have bool type
// If your compiler does not have bool then add   emulate_bool
// to your command line -D option or defined macros.
#ifdef emulate_bool
#   ifdef TVISION
#     define bool int
#     define true 1
#     define false 0
#   else
#     ifdef __BCPLUSPLUS__
      //BC++ bool type not available until 5.0
#        define BI_NO_BOOL
#        include <classlib/defs.h>
#     else
#        define bool int
#        define true 1
#        define false 0
#     endif
#  endif
#endif
#ifdef __BCPLUSPLUS__
#  include <systypes.h>
#else
#  ifdef unix
#     ifdef hpux
#        include <sys/_inttypes.h>
#     endif
#     ifdef Sun
#        include <sys/int_types.h>
#     endif
#     ifdef linux
#        include <idna.h>
#     endif
#     define int8 int8_t
#     define uint8 uint8_t
#     define int16 int16_t
#     define int32 int32_t
#     define uint16 uint16_t
#     define uint32 uint32_t
#  else
#     ifdef  _MSC_VER
#        include <BaseTSD.h>
#        define int8 INT8
#        define uint8 UINT8
#        define int16 INT16
#        define int32 INT32
#        define uint16 UINT16
#        define uint32 UINT32
#     else
#        ifndef OWL6
//          OWL version 6 already defines these types
#           define int8 char
#           define uint8 unsigned char
#           ifdef __WIN32_
#              define int16 short int
#              define int32 long
#              define uint16 unsigned short int
#              define uint32 unsigned long
#           else
#              define int16 int
#              define int32 long
#              define uint16 unsigned int
#              define uint32 unsigned long
#           endif
#        endif
#      endif
#  endif
#endif
typedef int8   sint8;
typedef int16  sint16;
typedef int32  sint32;
typedef uint8  nat8;
typedef uint16 nat16;
typedef uint32 nat32;
typedef const char * cASCIIz;    // constant null terminated char array
typedef char *       ASCIIz;     // null terminated char array
#endif
//primitive.h
5
Roger Nelson

Der C++ Standard sagt es so:

3.9.1, §2:

Es gibt fünf vorzeichenbehaftete Ganzzahltypen: "vorzeichenbehaftetes Zeichen", "kurzes int", "int", "langes int" und "langes langes int". In dieser Liste bietet jeder Typ mindestens so viel Speicherplatz wie in der Liste davor. Einfache Ints haben die natürliche Größe, die von der Architektur der Ausführungsumgebung vorgeschlagen wird (44). Die anderen vorzeichenbehafteten Integer-Typen werden bereitgestellt, um spezielle Anforderungen zu erfüllen.

(44) das heißt, groß genug, um jeden Wert im Bereich von INT_MIN und INT_MAX zu enthalten, wie im Header definiert <climits>.

Das Fazit: Es kommt darauf an, an welcher Architektur Sie arbeiten. Jede andere Annahme ist falsch.

4
Jérôme Radix