Qual è la differenza tra un int e un long in C ++?

Correggimi se sbaglio

int è di 4 byte, con un intervallo di valori da -2.147.483.648 a 2.147.483.647 (2 ^ 31),
lungo 4 byte, con un intervallo di valori da -2.147.483.648 a 2.147.483.647 (2 ^ 31)

Qual è la differenza in C ++? Possono essere usati in modo intercambiabile?

Dipende dall'implementazione.

Ad esempio, sotto Windows sono gli stessi, ma per esempio sui sistemi Alpha un long era di 64 bit mentre un int era di 32 bit. Questo articolo tratta le regole per il compilatore Intel C ++ su piattaforme variabili. Riassumere:

  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  

Le uniche garanzie che hai sono:

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

Vedi anche: È longgarantito che siano almeno 32 bit?

Quando si compila per x64, la differenza tra int e long è compresa tra 0 e 4 byte, a seconda del compilatore utilizzato.

GCC utilizza il modello LP64, il che significa che gli int sono a 32 bit ma i long sono a 64 bit in modalità a 64 bit.

MSVC ad esempio utilizza il modello LLP64, il che significa che sia int che long sono a 32 bit anche in modalità a 64 bit.

La specifica C ++ stessa (vecchia versione ma abbastanza buona per questo) lo lascia aperto.

Sono disponibili quattro tipi di numeri interi con segno: " signed char", " short int", " int" e " long int". In questo elenco, ogni tipo fornisce almeno lo stesso spazio di archiviazione di quelli che lo precedono nell'elenco. Gli int semplici hanno la dimensione naturale suggerita dall'architettura dell'ambiente di esecuzione *;

[Nota a piè di pagina: cioè sufficientemente grande da contenere qualsiasi valore nell'intervallo di INT_MIN e INT_MAX, come definito nell'intestazione <climits>. --- fine nota]

Come sottolinea Kevin Haines, gli int hanno la dimensione naturale suggerita dall'ambiente di esecuzione, che deve rientrare in INT_MIN e INT_MAX.

Lo standard C89 afferma che UINT_MAXdovrebbe essere almeno 2 ^ 16-1, USHRT_MAX2 ^ 16-1 e ULONG_MAX2 ^ 32-1. Questo fa un conteggio dei bit di almeno 16 per short e int e 32 per long. Per char si afferma esplicitamente che dovrebbe avere almeno 8 bit ( CHAR_BIT). C ++ eredita queste regole per il file limits.h, quindi in C ++ abbiamo gli stessi requisiti fondamentali per quei valori. Tuttavia, non dovresti derivare da ciò che int è almeno 2 byte. Teoricamente, char, int e long potrebbero essere tutti 1 byte, nel qual caso CHAR_BITdeve essere almeno 32. Ricorda solo che "byte" è sempre la dimensione di un char, quindi se char è più grande, un byte non è solo 8 bit qualsiasi Di Più.

Dipende dal tuo compilatore. Hai la certezza che un long sarà grande almeno quanto un int, ma non sei sicuro che lo sarà più.

Per la maggior parte, il numero di byte e l'intervallo di valori è determinato dall'architettura della CPU non da C ++. Tuttavia, C ++ stabilisce i requisiti minimi, che litb ha spiegato correttamente e Martin York ha commesso solo alcuni errori.

Il motivo per cui non puoi usare int e long in modo intercambiabile è perché non sono sempre della stessa lunghezza. C è stato inventato su un PDP-11 dove un byte aveva 8 bit, int era due byte e poteva essere gestito direttamente dalle istruzioni hardware. Poiché i programmatori C spesso avevano bisogno di operazioni aritmetiche a quattro byte, fu inventato long ed era di quattro byte, gestito dalle funzioni di libreria. Altre macchine avevano specifiche diverse. Lo standard C imponeva alcuni requisiti minimi.

Affidarsi all'implementazione del fornitore del compilatore di dimensioni di tipo primitivo tornerà a perseguitarti se mai compili il tuo codice su un'altra architettura di macchina, sistema operativo o compilatore di un altro fornitore.

La maggior parte dei fornitori di compilatori fornisce un file di intestazione che definisce i tipi primitivi con dimensioni di tipo esplicite. Questi tipi primitivi dovrebbero essere usati ogni volta che il codice può essere potenzialmente portato su un altro compilatore (leggilo SEMPRE in OGNI istanza). Ad esempio, la maggior parte dei compilatori UNIX ha int8_t uint8_t int16_t int32_t uint32_t. Microsoft ha INT8 UINT8 INT16 UINT16 INT32 UINT32. Preferisco Borland / CodeGear's int8 uint8 int16 uint16 int32 uint32. Questi nomi forniscono anche un piccolo promemoria della dimensione / intervallo del valore previsto.

Per anni ho usato i nomi dei tipi primitivi espliciti di Borland e #includeil seguente file di intestazione C / C ++ (primitive.h) che ha lo scopo di definire i tipi primitivi espliciti con questi nomi per qualsiasi compilatore C / C ++ (questo file di intestazione potrebbe non coprire ogni compilatore ma copre diversi compilatori che ho usato su Windows, UNIX e Linux, inoltre non definisce (ancora) i tipi a 64 bit).

#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

Lo standard C ++ lo dice in questo modo:

3.9.1, §2:

Esistono cinque tipi di interi con segno: "signed char", "short int", "int", "long int" e "long long int". In questo elenco, ogni tipo fornisce almeno lo stesso spazio di archiviazione di quelli che lo precedono nell'elenco. Gli int semplici hanno la dimensione naturale suggerita dall'architettura dell'ambiente di esecuzione (44); gli altri tipi di interi con segno vengono forniti per soddisfare esigenze speciali.

(44) cioè, sufficientemente grande da contenere qualsiasi valore nell'intervallo di INT_MIN e INT_MAX, come definito nell'intestazione <climits> .

La conclusione: dipende dall'architettura su cui stai lavorando. Ogni altra ipotesi è falsa.