В чем разница между int и long в C ++?

Поправьте меня, если я ошибаюсь,

int - 4 байта с диапазоном значений от -2 147 483 648 до 2 147 483 647 (2 ^ 31)
long - 4 байта с диапазоном значений от -2 147 483 648 до 2 147 483 647 (2 ^ 31)

В чем разница в C ++? Могут ли они использоваться как взаимозаменяемые?

Это зависит от реализации.

Например, в Windows они такие же, но, например, в системах Alpha long было 64 бита, тогда как int было 32 бита. В этой статье рассматриваются правила для компилятора Intel C ++ на переменных платформах. Подвести итоги:

  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  

Единственная гарантия, которая у вас есть:

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

Смотрите также: Является ли longгарантированно быть по крайней мере 32 бита?

При компиляции для x64 разница между int и long составляет где-то от 0 до 4 байтов, в зависимости от того, какой компилятор вы используете.

GCC использует модель LP64, что означает, что целые числа являются 32-битными, а длинные - 64-битными в 64-битном режиме.

Например, MSVC использует модель LLP64, что означает, что как целые, так и длинные числа являются 32-битными даже в 64-битном режиме.

Сама спецификация C ++ (старая версия, но достаточно хорошая для этого) оставляет это открытым.

Существует четыре целочисленных типа со знаком: ' signed char', ' short int', ' int' и ' long int'. В этом списке каждый тип обеспечивает как минимум такой же объем памяти, как и предшествующие ему в списке. Простые вставки имеют естественный размер, предполагаемый архитектурой среды исполнения *;

[Сноска: то есть достаточно большой, чтобы содержать любое значение в диапазоне INT_MIN и INT_MAX, как определено в заголовке <climits>. --- конец foonote]

Как указывает Кевин Хейнс, целые числа имеют естественный размер, предлагаемый средой выполнения, который должен соответствовать INT_MIN и INT_MAX.

В стандарте C89 указано, что UINT_MAXдолжно быть не менее 2 ^ 16-1, USHRT_MAX2 ^ 16-1 и ULONG_MAX2 ^ 32-1. Это составляет не менее 16 бит для коротких и целых чисел и 32 для длинных. Для char он явно указывает, что он должен иметь не менее 8 бит ( CHAR_BIT). C ++ наследует эти правила для файла limits.h, поэтому в C ++ у нас те же основные требования к этим значениям. Вы должны , однако не проистекают из того что ИНТ по крайней мере , 2 байта. Теоретически char, int и long могут быть 1 байтом, и в этом случае CHAR_BITдолжно быть не менее 32. Просто помните, что «байт» всегда равен размеру char, поэтому, если char больше, байт - это не только 8 бит. Больше.

Это зависит от вашего компилятора. Вам гарантируется, что long будет как минимум такого же размера, как int, но вам не гарантируется, что он будет больше.

По большей части количество байтов и диапазон значений определяется архитектурой ЦП, а не C ++. Однако C ++ устанавливает минимальные требования, которые подробно объяснены, а Мартин Йорк допустил лишь несколько ошибок.

Причина, по которой вы не можете использовать int и long как взаимозаменяемые, заключается в том, что они не всегда имеют одинаковую длину. C был изобретен на PDP-11, где байт имел 8 бит, int - два байта и мог обрабатываться напрямую с помощью аппаратных инструкций. Поскольку программистам на C часто требовалась четырехбайтовая арифметика, было изобретено long, и это было четыре байта, обрабатываемых библиотечными функциями. Остальные машины имели другие характеристики. Стандарт C предъявлял некоторые минимальные требования.

Если вы когда-нибудь компилируете свой код на другой машинной архитектуре, ОС или компиляторе другого поставщика, то полагаться на реализацию поставщика компилятора примитивных размеров типов БУДЕТ преследовать вас.

Большинство поставщиков компиляторов предоставляют файл заголовка, который определяет примитивные типы с явными размерами типов. Эти примитивные типы следует использовать, когда код потенциально может быть перенесен на другой компилятор (читайте это ВСЕГДА в КАЖДОМ экземпляре). Например, у большинства компиляторов UNIX есть int8_t uint8_t int16_t int32_t uint32_t. У Microsoft есть INT8 UINT8 INT16 UINT16 INT32 UINT32. Я предпочитаю Borland / CodeGear's int8 uint8 int16 uint16 int32 uint32 . Эти имена также напоминают размер / диапазон предполагаемого значения.

В течение многих лет я использовал явные имена примитивных типов Borland и #includeследующий файл заголовка C / C ++ (primitive.h), который предназначен для определения явных примитивных типов с этими именами для любого компилятора C / C ++ (этот файл заголовка может фактически не охватывать все компилятор, но он охватывает несколько компиляторов, которые я использовал в Windows, UNIX и Linux, он также (пока) не определяет 64-битные типы).

#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

Стандарт C ++ говорит об этом так:

3.9.1, §2:

Существует пять целочисленных типов со знаком: «signed char», «short int», «int», «long int» и «long long int». В этом списке каждый тип обеспечивает как минимум такой же объем памяти, как и предшествующие ему в списке. Простые вставки имеют естественный размер, предполагаемый архитектурой среды исполнения (44); другие целочисленные типы со знаком предоставляются для особых нужд.

(44) то есть достаточно большой, чтобы содержать любое значение в диапазоне INT_MIN и INT_MAX, как определено в заголовке <climits> .

Вывод: это зависит от того, над какой архитектурой вы работаете. Любое другое предположение неверно.