Long int си: С | Типы данных

Пределы целых чисел в C и C++

Twitter LinkedIn Facebook Адрес электронной почты

• Статья
• 03/03/2023
• Чтение занимает 2 мин

Блок, относящийся только к системам Microsoft

Ограничения для целочисленных типов в C и C++ представлены в следующей таблице. Эти ограничения заданы в стандартном файле заголовка C <limits.h>. Стандартный файл заголовка C++ <limits> содержит <climits>, который включает в себя <limits.h>.

В Microsoft C также допускается объявление целочисленных переменных с указанием размера, которые относятся к целочисленным типам с размером 8, 16, 32 или 64 бит. Дополнительные сведения о них см. в статье Целочисленные типы с указанием размера.

Ограничения для целочисленных констант

Константа	Значение	Значение
CHAR_BIT	Количество битов в наименьшей переменной, которая не является битовым полем.	8
SCHAR_MIN	Минимальное значение для переменной типа signed char.	–128
SCHAR_MAX	Максимальное значение для переменной типа signed char.	127
UCHAR_MAX	Максимальное значение для переменной типа unsigned char.	255 (0xff)
CHAR_MIN	Минимальное значение для переменной типа char.	–128 (или 0, если используется параметр /J)
CHAR_MAX	Максимальное значение для переменной типа char.	–127 (или 255, если используется параметр /J)
MB_LEN_MAX	Максимальное количество байтов в многосимвольной константе.	5
SHRT_MIN	Минимальное значение для переменной типа short.	-32768
SHRT_MAX	Максимальное значение для переменной типа short.	32767
USHRT_MAX	Максимальное значение для переменной типа unsigned short.	65 535 (0xffff)
INT_MIN	Минимальное значение для переменной типа int.	-2147483647 — 1
INT_MAX	Максимальное значение для переменной типа int.	2147483647
UINT_MAX	Максимальное значение для переменной типа unsigned int.	4 294 967 295 (0xffffffff)
LONG_MIN	Минимальное значение для переменной типа long.	-2147483647 — 1
LONG_MAX	Максимальное значение для переменной типа long.	2147483647
ULONG_MAX	Максимальное значение для переменной типа unsigned long.	4 294 967 295 (0xffffffff)
LLONG_MIN	Минимальное значение для переменной типа long long.	–9 223 372 036 854 775 807 – 1
LLONG_MAX	Максимальное значение для переменной типа long long.	9 223 372 036 854 775 807
ULLONG_MAX	Максимальное значение для переменной типа unsigned long long.	18 446 744 073 709 551 615 (0xffffffffffffffff)

Если значение превышает максимально возможное представление целочисленного типа, компилятор Microsoft выдает ошибку.

Завершение блока, относящегося только к системам Майкрософт

См. также

Целочисленные константы в C

какие существуют int, float, char, double, wchar_t, bool и void, как определить, таблица

В этом руководстве мы узнаем об основных типах данных, таких как int, float, char и т.д. в программировании на C++, с помощью примеров.

Что такое типы данных в C++?

Типа данных в C++ – это объявления переменных. Они определяют тип и размер данных, связанных с переменными. Например:

int age = 13;

Здесь age – переменная типа int, это означает, что переменная может хранить только целые числа размером 2 или 4 байта.

Основные типы данных

В таблице ниже показаны основные типы данных в C++, их значение и размеры (в байтах):

Тип данных	Значение	Размер (в байтах)
int	Целое число	2 или 4
float	Плавающая точка	4
double	Двойная плавающая точка	8
char	символ	1
wchar_t	Широкий характер	2
bool	Булево	1
void	Пустой

Теперь давайте обсудим эти фундаментальные типы данных более подробно.

1. int

• Ключевое слово int в С++ используется для обозначения целых чисел. 12

  3. char

  • Ключевое слово char используется для символов.
  • Его размер составляет 1 байт.
  • В C++ символы заключаются в одинарные кавычки ”.
  • Например:

  char test = 'h';
  

  Примечание. В С++ целочисленное значение хранится в переменной типа char, а не в самом символе.

  4. wchar_t

  • Широкий символ wchar_t похож на тип данных char, за исключением того, что его размер составляет 2 байта вместо 1.
  • Он используется для представления символов, для использования которых требуется больше памяти, чем для одного символа.
  • Например:

  wchar_t test = L'ם'  // storing Hebrew character;
  
  

  Обратите внимание на букву L перед кавычками.

  Примечание. В C++ 11 также представлены два других типа символов фиксированного размера – char16_t и char32_t.

  5. bool

  • Тип данных bool имеет одно из двух возможных значений: true или false.
  • Логические значения используются в условных операторах и циклах.
  • Например:

  bool cond = false;
  

  6. void

  • Ключевое слово void указывает на отсутствие данных. Это означает «ничего» или «не имеет значения».
  • Мы будем использовать void, когда узнаем о функциях и указателях.

  Примечание. Мы не можем объявлять переменные типа void.

  Модификаторы типа

  Мы можем дополнительно изменить некоторые из основных типов данных с помощью модификаторов типов. В C++ есть 4 модификатора типа:

  • signed;
  • unsigned;
  • short;
  • long.

  Мы можем изменить следующие типы данных с помощью вышеуказанных модификаторов:

  • int;
  • double;
  • char.

  Список измененных типов данных

  Тип данных	Размер (в байтах)	Значение
  signed int	4	используется для целых чисел (эквивалентно int)
  unsigned int	4	может хранить только положительные целые числа
  short	2	используется для небольших целых чисел (от -32768 до 32767)
  long	не менее 4	используется для больших целых чисел (эквивалент long int)
  unsigned long	4	используется для больших положительных целых чисел или 0 (эквивалент unsigned long int)
  long long	8	используется для очень больших целых чисел (эквивалент long long int)
  unsigned long long	8	используется для очень больших положительных целых чисел или 0 (эквивалент unsigned long long int)
  long double	12	используется для больших чисел с плавающей запятой
  signed char	1	используется для символов (гарантированный диапазон от -127 до 127)
  unsigned char	1	используется для символов (от 0 до 255)

  Посмотрим на несколько примеров.

  long b = 4523232;
  long int c = 2345342;
  long double d = 233434.56343;
  short d = 3434233; // Error! out of range
  unsigned int a = -5;    // Error! can only store positive numbers or 0
  

  Производные типы данных

  Типы данных, производные от основных типов данных, являются производными типами. Например: массивы, указатели, типы функций, структуры и т.д.

  Архитектура процессора

  . Почему в С++ типы int и long имеют размер 4 байта?

  спросил 10 лет, 4 месяца назад

  Изменено 9 лет, 9 месяцев назад

  Просмотрено 15 тысяч раз

  Многие источники, включая Microsoft, ссылаются как на тип int, так и на long как на 4 байта и имеющий диапазон (со знаком) от -2 147 483 648 до 2 147 483 647.

  Какой смысл иметь длинный примитивный тип, если он на самом деле не обеспечивает более широкий диапазон значений?
  • c++
  • архитектура процессора

  8

  Единственное, что гарантируется для целочисленных типов:

  1. sizeof(char) == 1
  2. sizeof(char) <= sizeof(short)
  3. sizeof(short) <= sizeof(int)
  4. sizeof(int) <= sizeof(long)
  5. sizeof(long) <= sizeof(long long)
  6. sizeof(char) * CHAR_BIT >= 8
  7. sizeof(short) * CHAR_BIT >= 16
  8. sizeof(int) * CHAR_BIT >= 16
  9. sizeof(long) * CHAR_BIT >= 32
  10. sizeof(long long) * CHAR_BIT >= 64

  Остальные вещи определяются реализацией. Благодаря (4) и long , и int могут иметь одинаковый размер, но он должен быть не менее 32 бит (благодаря (9)).

  13

  Стандарт C++ указывает только, что long равно как минимум такому же большому , как int , поэтому нет ничего криминального в сценарии, когда точно такое же большое : это полностью определяется реализацией. На разных платформах размеры могут иметь значение, например, у меня есть int размера 4 и long размера 8 в данный момент на моей машине с Linux.

  1

  Как указывали другие, предположение, лежащее в основе вопроса, верно лишь частично, т.е. не выполняется для некоторых платформ. Если вы действительно хотите понять, как мы пришли к текущей ситуации, «Долгая дорога к 64 битам» Дж. Маши даст вам хорошее представление о различных силах и их взаимодействии.

  Краткий обзор, C начался с char (8 бит) и int (16 бит). Затем добавили коротких (16 бит) и длинных (32 бита), а int может быть 16- или 32-битным, в зависимости от того, что было естественным на платформе, и требований обратной совместимости. Когда появились 64 бита, long long был добавлен как 64-битный тип, и были внесены некоторые изменения в меньшие типы на 64-битных платформах. Все стабилизировалось с 32-битным int , но long сохраняло различные определения, некоторые 64-битные платформы имели 64-битное long , в то время как другие (возможно, только Windows?) сохраняли long до 32 бит, вероятно, из-за разных давление обратной совместимости (у Unix долгая история принятия long имеет тот же размер, что и указатель, в API Windows было больше остатков того времени, когда int было 16-битным, и, таким образом, long был единственным 32-битным типом). BTW typedefs ( intXX_t , intptr_t ) были добавлены, чтобы сделать намерение более ясным, с риском того, что семейство intXX_t форсирует постоянный размер, если он действительно не нужен.

  1

  Нет, на некоторых платформах только 4 байта. Стандарт C++ оставляет размер определяемым реализацией.

  На других платформах может быть другой размер.

  2

  Он не обязательно должен быть больше. Точно так же GCC, например, обычно имеет длинных , которые должны быть определены как 8 байтов, когда я использовал его на своей машине. Формулировка стандарта обычно гласит, что эти типы «должны быть размером не менее X» (например, взгляните на окончательно стандартизированный long long в C++11. пока он соответствует требованиям.По стандарту кто-то мог сделать long long 256 бит, и это было бы совершенно законно.

  Спецификация языка C++ просто указывает, что размер long должен быть не меньше размера int .

  Раньше было стандартно иметь int = 2 байта и long = 4 байта. По какой-то причине int выросло, а long осталось прежним (по крайней мере, на компиляторах Windows). Я могу только предполагать, что long остался тем же из соображений обратной совместимости...

  3

  Никто не ответил на ваш вопрос, кроме, может быть, AProgrammer.

  Стандарт C/C++ определен так, как описал Гривес. Это позволяет реализовать язык C и C++, где производитель компилятора может определить размеры, наиболее подходящие для компьютерной архитектуры. Некоторое время (для Windows 3.1 и более ранних версий, то есть до Windows 95) код C для Windows имел 16-битное целое число, тогда как многие платформы UNIX, такие как Solaris, HPUX и AIX, имели 32-битное целое число.

  Однако современные микрокомпьютеры (начиная с 386-го) имеют полные 32-битные регистры, и адресация памяти, выровненная по 32-битному, намного быстрее, чем доступ с 16-битным приращением. Таким образом, код намного эффективнее с 32-битным целым числом, особенно для массивов целых чисел, чем с 16-битным целым числом.

  Чтобы имитировать 16-битное целое число в 32-битном регистре, вы также должны переполнить 16-й бит вместо 32-го. Так что с 32-битным целым числом проще, даже если у вас есть только 32-битные длинные.

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

  Зарегистрируйтесь или войдите

  Зарегистрируйтесь с помощью Google

  Зарегистрироваться через Facebook

  Зарегистрируйтесь, используя адрес электронной почты и пароль

  Опубликовать как гость

  Электронная почта

  Обязательно, но не отображается

  Опубликовать как гость

  Электронная почта

  Требуется, но не отображается

  c — Каков исторический контекст для long и int, которые часто имеют одинаковый размер?

  спросил 11 лет, 9 месяцев назад

  Изменено 11 лет, 9 месяцев назад

  Просмотрено 1к раз

  Согласно многочисленным ответам здесь, long и int имеют размер 32 бита на распространенных платформах в C и C++ (Windows и Linux, 32 и 64 бит. ) (я знаю, что нет стандарта, но на практике это наблюдаемые размеры.)

  Итак, мой вопрос: как это произошло? Почему у нас есть два типа одного размера? Раньше я всегда предполагал, что long большую часть времени будет 64-битным, а int 32-битным. Я не говорю, что это «должно» быть так или иначе, мне просто любопытно, как мы сюда попали.

  • c
  • размер
  • история
  • int
  • long-integer

  3

  От C99 обоснование (PDF) раздела 6.2.5:

  [...] В 1970-х годах 16-битный C (для PDP-11) первый представленный файл информация с 16-битными целыми числами, которые быстро устарели из-за дисков прогресс. Люди перешли на 32-битную файловая система, сначала с использованием int[2] конструкции, которые были не только неудобно, но и неэффективно переносим на 32-битное оборудование.

  Чтобы решить проблему, тип длинный был добавлен в язык, хотя это требовало C на PDP-11, чтобы генерировать несколько операций для имитировать 32-битную арифметику. Даже как Стали доступны 32-битные миникомпьютеры наряду с 16-битными системами люди по-прежнему б/у int для эффективности, резервирования long для случаев, когда большие целые числа были действительно нужны, так как длинных были заметно менее эффективен на 16-битных системы. Оба короткие и длинные были добавлено в C, что делает коротким доступным для 16 бит, long для 32 бит и int как удобно для производительности. Закрывать не хотелось числа 16 или 32 в язык, как компиляторы C существовали по крайней мере 24- и 36-битные процессоры, а скорее для укажите имена, которые можно использовать для 32 бита по мере необходимости.

  PDP-11 C мог быть повторно реализован с int как 32-битный, таким образом избегая необходимости в long ; но это заставило бы людей измениться большинство случаев использования int до short или страдать от серьезного снижения производительности на PDP-11. В добавок к потенциальное влияние на исходный код, воздействие на существующий объектный код и файлы данных были бы хуже, даже в 1976 году. К 1990-м годам с огромным установленная база программного обеспечения, и с широкое использование динамических ссылок библиотеки, влияние изменения размер общего объекта данных в существующая среда настолько высока, что мало кто будет это терпеть, хотя это может быть приемлемо при создании новая среда. Поэтому многие продавцы, чтобы избежать конфликтов пространств имен, добавил 64-битное целое к их 32-битному Среды C, использующие новое имя, из который длинный длинный был самым широко используемый. [...]

  2

  Исторически большинство размеров и типов в C можно проследить до архитектуры PDP-11. Это были байты, слова (16 бит) и двойные слова (32 бита). Когда C и UNIX были перемещены на другую машину (я думаю, Interdata 832), длина слова была 32 бита. Чтобы обеспечить совместимость исходного кода, long и int были определены так, чтобы строго

  sizeof(short) ≤ sizeof(int) ≤ sizeof(long) .

  Большинство машин теперь имеют sizeof(int) = sizeof(long) , потому что 16 бит уже неудобны, но у нас есть long long, чтобы получить 64 бита, если это необходимо.

  Обновление строго говоря, я должен был сказать "компиляторы", потому что разные разработчики компиляторов могут принимать разные решения для одной и той же архитектуры набора инструкций. GCC и Microsoft, например.

  2

  Еще в конце 70-х и начале 80-х многие архитектуры были 16-битными, поэтому обычно char был 8-битным, int — 16-битным, а long — 32-битным. В конце 80-х произошел общий переход на 32-битные архитектуры, поэтому int стал 32-битным, но долгое время оставался 32-битным.

  За последние 10 лет произошел переход к 64-битным вычислениям, и теперь у нас есть несколько разных моделей, наиболее распространенной из которых является LP64, где int по-прежнему 32-битные, а long теперь 64-битные.

  Итог: не делайте никаких предположений о размерах различных целочисленных типов (конечно, кроме тех, которые определены в стандарте), и если вам нужны типы фиксированного размера, используйте .

  Насколько я понимаю, стандарт C требует, чтобы long имел длину не менее 32 бит и был не меньше int . С другой стороны, int всегда (я думаю) равен собственному размеру слова архитектуры.

  Имейте в виду, что когда разрабатывались стандарты, 32-битные машины не были распространены; изначально int , вероятно, был бы родным 16-битным, а long был бы вдвое длиннее 32-битного.

  2

  В 16-разрядных операционных системах int был 16-разрядным, а long — 32-разрядным.