Какой стандарт C ++ указывает размер типа int, long?

Стандарт C++ не определяет размер целочисленных типов в байтах, но он определяет минимальные диапазоны, которые они должны быть в состоянии содержать. Можно вывести минимальный размер в битах от необходимого диапазона. Можно вывести минимальный размер в байтах от этого и значения CHAR_BIT макрос, который определяет число битов в байте (во всех кроме самых неясных платформ, которые это 8, и это не могут быть меньше чем 8).

Одно дополнительное ограничение для char состоит в том, что его размер всегда - 1 байт, или CHAR_BIT биты (отсюда имя).

Минимальные диапазоны требуемый стандартом (страница 22):

и Диапазоны Типа данных на [1 128] MSDN:

1. signed char:-127 к 127 (примечание, не-128 к 127; это размещает 1's-дополнение и платформы знака-и-величины)
2. unsigned char: от 0 до 255
3. "плоскость" char: тот же диапазон как signed char или unsigned char, определенный реализацией
4. signed short:-32767 к 32 767
5. unsigned short: от 0 до 65 535
6. signed int:-32767 к 32 767
7. unsigned int: от 0 до 65 535
8. signed long:-2147483647 к 2147483647
9. unsigned long: от 0 до 4294967295
10. signed long long:-9223372036854775807 к 9223372036854775807
11. unsigned long long: от 0 до 18446744073709551615

C++ А (или C) реализация может определить размер типа в байтах sizeof(type) к любому значению, целых

1. , выражение sizeof(type) * CHAR_BIT оценивает достаточно к многому битов высотой для содержания требуемых диапазонов, и
2. , упорядочивание типа все еще допустимо (например, sizeof(int) <= sizeof(long)).

определенные для фактической реализации диапазоны могут быть найдены в [1 121] заголовок в C, или <climits> в C++ (или еще лучше, шаблонными std::numeric_limits в [1 124] заголовок).

, Например, это - то, как Вы найдете максимальный диапазон для [1 125]:

C:

#include <limits.h>
const int min_int = INT_MIN;
const int max_int = INT_MAX;

C++ :

#include <limits>
const int min_int = std::numeric_limits<int>::min();
const int max_int = std::numeric_limits<int>::max();

Нет, нет никакого стандарта для размеров шрифта. Стандарт только требует что:

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

лучшая вещь можно сделать, если Вы хотите переменные, фиксированные размеры должны использовать макросы как это:

#ifdef SYSTEM_X
  #define WORD int
#else
  #define WORD long int
#endif

Тогда можно использовать WORD для определения переменных. Не то, чтобы мне нравится это, но это большая часть портативного устройства путь.

1) Таблица N1 в статье" проблемы, о которых забывают, 64-разрядной разработки программ "

2) " Модель данных "

Как упомянуто размер должен отразить текущую архитектуру. Вы могли взять пик вокруг в limits.h, если Вы хотите видеть, как Ваш текущий компилятор обрабатывает вещи.

Для чисел с плавающей точкой существует стандарт (IEEE754) : плавания составляют 32 бита, и удваивается, 64. Это - аппаратный стандарт, не стандарт C++, таким образом, компиляторы могли теоретически определить плавание и удвоиться до некоторого другого размера, но на практике я никогда не видел архитектуру, которая использовала что-либо различное.

Существует стандарт, и он определяется в различных документах стандартов (ISO, ANSI и этажерка).

Википедия имеет большую страницу, объясняя различные типы и макс., которое они могут сохранить: Целое число в Информатике.

однако даже со стандартным компилятором C++ можно узнать относительно легкое использование следующего фрагмента кода:

#include <iostream>
#include <limits>


int main() {
    // Change the template parameter to the various different types.
    std::cout << std::numeric_limits<int>::max() << std::endl;
}

Документация для станд.:: numeric_limits может быть найден в Roguewave. Это включает множество других команд, которые можно назвать для обнаружения различных пределов. Это может использоваться с любым произвольным типом, который передает размер, например, станд.:: streamsize.

ответ John's содержит лучшее описание, поскольку они, как гарантируют, будут содержать. Какая платформа Вы идете, существует другая хорошая страница, которая вдается в большее количество подробностей относительно того, сколько битов каждый тип ДОЛЖЕН содержать: международные типы , которые определяются в стандарте.

я надеюсь, что это помогает!

При необходимости в типах фиксированного размера используйте типы как uint32_t (целое число без знака 32 бита) определенный в stdint.h. Они определяются в C99.

Можно использовать переменные, обеспеченные библиотеками такой как OpenGL, Qt, и т.д.

, Например, Qt обеспечивает qint8 (гарантировал, что был 8-разрядным на всех платформах, поддерживаемых QT), qint16, qint32, qint64, quint8, quint16, quint32, quint64, и т.д.

Обновленный: C++ 11 принес типы от TR1 официально в стандарт:

• долгое длинное целое
• неподписанное долгое длинное целое

И "размерные" типы от <cstdint>

• int8_t
• int16_t
• int32_t
• int64_t
• (и неподписанные дубликаты).

Плюс Вы доберитесь:

• int_least8_t
• int_least16_t
• int_least32_t
• int_least64_t
• Плюс неподписанные дубликаты.

Эти типы представляют самые маленькие целые типы, по крайней мере, с конкретным количеством битов. Аналогично существуют "самые быстрые" целые типы, по крайней мере, с конкретным количеством битов:

• int_fast8_t
• int_fast16_t
• int_fast32_t
• int_fast64_t
• Плюс неподписанные версии.

то, Что "быстро" означает, во всяком случае, до реализации. Это не должно быть самым быстрым во всех целях также.

Как Вы упомянули - это в основном зависит от компилятора и платформы. Для этого проверьте стандарт ANSI, , http://home.att.net/~jackklein/c/inttypes.html

Вот является тем для компилятора Microsoft: Диапазоны Типа данных .

На практике нет такой вещи. Часто можно ожидать std::size_t представлять неподписанный собственный целочисленный размер на текущей архитектуре. т.е. 16-разрядный, 32-разрядный или 64-разрядный, но это не всегда имеет место, как указано в комментариях к этому ответу.

Насколько все другие встроенные типы идут, это действительно зависит от компилятора. Вот две выборки, взятые из текущего рабочего проекта последнего стандарта C++:

существует пять стандартных типов целого числа со знаком: символ со знаком, короткое целое, интервал, длинное целое и долгое длинное целое. В этом списке каждый тип обеспечивает, по крайней мере, столько же устройства хранения данных сколько те, которые предшествуют ему в списке.

Для каждого из стандартных типов целого числа со знаком, там существует соответствие (но отличающийся) стандартный тип беззнаковых целых чисел: неподписанный символ, интервал короткого целого без знака, неподписанный интервал, неподписанное длинное целое и неподписанное долгое длинное целое, каждый из которых занимает ту же сумму устройства хранения данных и имеет те же требования выравнивания.

, Если Вы хотите Вам, может статически (время компиляции) утверждать sizeof эти фундаментальные типы. Это предупредит людей для размышления о портировании кода, если sizeof предположения изменятся.

Для 32-разрядных систем 'фактический' стандарт является ILP32 — то есть, int, long и указатель все 32-разрядные количества.

Для 64-разрядных систем, основной Unix 'фактический' стандарт является LP64 — long, и указатель являются 64-разрядными (но int является 32-разрядным). Windows 64-разрядный стандарт является LLP64 — long long и указатель, является 64-разрядным (но long, и int являются оба 32-разрядными).

Когда-то, некоторые системы Unix использовали организацию ILP64.

Ни один из этих фактических стандартов не узаконен стандартом C (ISO/IEC 9899:1999), но всем разрешает он.

И, по определению, sizeof(char) 1, несмотря на тест в Perl настраивают сценарий.

Примечание, что были машины (Crays), где CHAR_BIT было намного больше, чем 8. Это означало, IIRC, это sizeof(int) равнялось также 1, потому что и char и int были 32-разрядными.

Существует стандарт.

Стандарт C90 требует этого

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

Стандарт C99 требует этого

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

Вот спецификации C99. Страница 22 детализирует размеры различных целочисленных типов.

Вот международные размеры шрифта (биты) для платформ Windows:

Type           C99 Minimum     Windows 32bit
char           8               8
short          16              16
int            16              32
long           32              32
long long      64              64

Если Вы обеспокоены мобильностью, или Вы хотите название типа, отражает размер, можно посмотреть на заголовок <inttypes.h>, где следующие макросы доступны:

int8_t
int16_t
int32_t
int64_t

int8_t как гарантируют, будет 8 битов, и int16_t как гарантируют, будет 16 битов, и т.д.