Qual é a diferença entre um int e um long em C ++?

Corrija-me se eu estiver errada,

int é de 4 bytes, com um intervalo de valores de -2.147.483.648 a 2.147.483.647 (2 ^ 31) de
comprimento é de 4 bytes, com um intervalo de valores de -2.147.483.648 a 2.147.483.647 (2 ^ 31)

Qual é a diferença em C ++? Eles podem ser usados ​​de forma intercambiável?

É dependente da implementação.

Por exemplo, no Windows, eles são os mesmos, mas, por exemplo, nos sistemas Alpha, um comprimento era de 64 bits, enquanto um int era de 32 bits. Este artigo aborda as regras para o compilador Intel C ++ em plataformas variáveis. Para resumir:

  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  

A única garantia que você tem é:

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

Veja também: É longgarantido que tenha pelo menos 32 bits?

Ao compilar para x64, a diferença entre int e long está entre 0 e 4 bytes, dependendo do compilador usado.

O GCC usa o modelo LP64, o que significa que as entradas são de 32 bits, mas os compridos são de 64 bits no modo de 64 bits.

A MSVC, por exemplo, usa o modelo LLP64, o que significa que ints e longs são 32 bits, mesmo no modo de 64 bits.

A própria especificação C ++ (versão antiga, mas boa o suficiente para isso) deixa em aberto.

Existem quatro tipos de números inteiros assinados: ' signed char', ' short int', ' int' e ' long int'. Nesta lista, cada tipo fornece pelo menos a quantidade de armazenamento que os anteriores à lista. Ints simples têm o tamanho natural sugerido pela arquitetura do ambiente de execução *;

[Nota de rodapé: ou seja, grande o suficiente para conter qualquer valor no intervalo de INT_MIN e INT_MAX, conforme definido no cabeçalho <climits>. --- foonote final]

Como Kevin Haines salienta, as entradas têm o tamanho natural sugerido pelo ambiente de execução, que deve se encaixar em INT_MIN e INT_MAX.

O padrão C89 afirma que UINT_MAXdeve ser pelo menos 2 ^ 16-1, USHRT_MAX2 ^ 16-1 e ULONG_MAX2 ^ 32-1. Isso faz uma contagem de bits de pelo menos 16 para short e int e 32 por muito tempo. Para char, afirma explicitamente que deve ter pelo menos 8 bits ( CHAR_BIT). O C ++ herda essas regras para o arquivo limits.h, portanto, no C ++, temos os mesmos requisitos fundamentais para esses valores. No entanto, você não deve derivar que int seja de pelo menos 2 bytes. Teoricamente, char, int e long podem ter 1 byte, e nesse caso CHAR_BITdeve ter pelo menos 32. Lembre-se de que "byte" é sempre do tamanho de um char; portanto, se char for maior, um byte não terá apenas 8 bits Mais.

Depende do seu compilador. Você tem a garantia de que um longo será pelo menos tão grande quanto um int, mas você não tem a garantia de que será mais.

Na maioria das vezes, o número de bytes e o intervalo de valores são determinados pela arquitetura da CPU e não pelo C ++. No entanto, o C ++ define requisitos mínimos, o que litb explicou corretamente e Martin York cometeu apenas alguns erros.

A razão pela qual você não pode usar int e long intercambiavelmente é porque eles nem sempre têm o mesmo comprimento. C foi inventado em um PDP-11, onde um byte tinha 8 bits, int tinha dois bytes e poderia ser tratado diretamente por instruções de hardware. Como os programadores C geralmente precisavam de aritmética de quatro bytes, o tempo foi inventado e eram quatro bytes, manipulados pelas funções da biblioteca. Outras máquinas tinham especificações diferentes. O padrão C impôs alguns requisitos mínimos.

Confiar na implementação de tamanhos de tipos primitivos do fornecedor do compilador voltará a assombrá-lo se você compilar seu código em outra arquitetura de máquina, SO ou compilador de outro fornecedor.

A maioria dos fornecedores de compiladores fornece um arquivo de cabeçalho que define tipos primitivos com tamanhos explícitos. Esses tipos primitivos devem ser usados ​​sempre que o código for potencialmente portado para outro compilador (leia-o como SEMPRE em TODAS as instâncias). Por exemplo, a maioria dos compiladores UNIX possui int8_t uint8_t int16_t int32_t uint32_t. Microsoft tem INT8 UINT8 INT16 UINT16 INT32 UINT32. Eu prefiro o Borland / CodeGear int8 uint8 int16 uint16 int32 uint32. Esses nomes também fornecem um pequeno lembrete do tamanho / intervalo do valor pretendido.

Por anos, usei os nomes explícitos de tipos primitivos da Borland e #includeo seguinte arquivo de cabeçalho C / C ++ (primitive.h), que tem como objetivo definir os tipos primitivos explícitos com esses nomes para qualquer compilador C / C ++ (esse arquivo de cabeçalho pode, na verdade, não cobrir todos os compilador, mas abrange vários compiladores que usei no Windows, UNIX e Linux, mas ainda não define tipos de 64 bits).

#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

O padrão C ++ diz assim:

3.9.1, §2:

Existem cinco tipos de números inteiros assinados: "caractere assinado", "int curto", "int", "int longo" e "int longo longo". Nesta lista, cada tipo fornece pelo menos a quantidade de armazenamento que os anteriores à lista. Ints simples têm o tamanho natural sugerido pela arquitetura do ambiente de execução (44); os outros tipos de números inteiros assinados são fornecidos para atender a necessidades especiais.

(44), ou seja, grande o suficiente para conter qualquer valor no intervalo de INT_MIN e INT_MAX, conforme definido no cabeçalho <climits> .

A conclusão: depende de qual arquitetura você está trabalhando. Qualquer outra suposição é falsa.