Пространства имён
Варианты
Действия

Фундаментальные типы

Материал из cppreference.com
< cpp‎ | language
 
 
Язык С++
Общие темы
Управление потоком
Операторы условного выполнения
if
Операторы итерации (циклы)
Операторы перехода
Функции
Объявление функции
Выражение лямбда-функции
Спецификатор inline
Спецификации динамических исключений (до C++17*)
Спецификатор noexcept (C++11)
Исключения
Пространства имён
Типы
Спецификаторы
decltype (C++11)
auto (C++11)
alignas (C++11)
Спецификаторы длительности хранения
Инициализация
Выражения
Альтернативные представления
Литералы
Логические - Целочисленные - С плавающей запятой
Символьные - Строковые - nullptr (C++11)
Определяемые пользователем (C++11)
Утилиты
Атрибуты (C++11)
Types
Объявление typedef
Объявление псевдонима типа (C++11)
Casts
Неявные преобразования - Явные преобразования
static_cast - dynamic_cast
const_cast - reinterpret_cast
Выделение памяти
Классы
Свойства функции класса
explicit (C++11)
static
Специальные функции-элементы
Шаблоны
Разное
 

(Смотрите также тип для обзора системы типов и список утилит, связанных с типами, которые предоставляются библиотекой C++)

Содержание

[править] Тип void

void - тип с пустым набором значений. Это неполный тип, который не может быть завершён (следовательно, объекты типа void запрещены). Нет ни массивов типа void, ни ссылок на void. Однако, указатели на void и возвращаемый тип void функции (процедуры на других языках ) разрешены.

[править] std::nullptr_t (начиная с C++11)

Определено в заголовочном файле <cstddef>
typedef decltype(nullptr) nullptr_t;
(начиная с C++11)

std::nullptr_t это тип литерала нулевого указателя, nullptr. Это отдельный тип, который сам по себе не является типом указателя или указателем на тип элемента. Его значение константа нулевого указателя (смотрите NULL) и может быть неявно преобразован в любой указатель и указатель на тип элемента.

sizeof(std::nullptr_t) равно sizeof(void *).

[править] Модели данных

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

32-битные системы:

  • LP32 или 2/4/4 (int 16-битный, long и указатель 32-битные)
  • Win16 API
  • ILP32 или 4/4/4 (int, long, и указатель 32-битные);
  • Win32 API
  • Unix и Unix-подобные системы (Linux, macOS)

64-битные системы:

  • LLP64 или 4/4/8 (int и long 32-битные, указатель 64-битный)
  • Win32 API (также называемой Windows API) с целью компиляции 64-bit ARM (AArch64) или x86-64 (она же x64)
  • LP64 или 4/8/8 (int 32-битный, long и указатель 64-битные)
  • Unix и Unix-подобные системы (Linux, macOS)

Остальные модели встречаются очень редко. Например, ILP64 (8/8/8: int, long и указатель 64-битные) появились только в некоторых ранних 64-битных Unix системах (например UNICOS на Cray).

[править] целочисленные типы

[править] Стандартные целочисленные типы

int это базовый целочисленный тип. Ключевое слово int может быть опущено, если используется какой-либо из модификаторов, перечисленных ниже. Если модификаторы длины отсутствуют, ширина гарантированно будет не менее 16 бит. Однако в 32/64 битных системах почти всегда гарантируется ширина не менее 32 бит (смотрите ниже).
[править] Модификаторы

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

  • Знаковость
signed - целевой тип будет иметь знаковое представление (это значение по умолчанию, если не указано)
unsigned - целевой тип будет иметь представление без знака
  • Размер
short - целевой тип будет оптимизирован по использованию памяти и будет иметь ширину не менее 16 бит.
long - целевой тип будет иметь ширину не менее 32 бит.

long long - целевой тип будет иметь ширину не менее 64 бит.
(начиная с C++11)

Примечание: как и для всех спецификаторов типов, разрешён любой порядок: unsigned long long int и long int unsigned long именуют один и тот же тип.

{anchor|Integer properties}}

[править] Свойства

В следующей таблице приведены все доступные целочисленные типы и их свойства в различных общих моделях данных:

Спецификатор типа Эквивалентный тип Ширина в битах согласно модели данных
Стандарт C++ LP32 ILP32 LLP64 LP64
short
short int не меньше чем
16
16 16 16 16
short int
signed short
signed short int
unsigned short
unsigned short int
unsigned short int
int
int не меньше чем
16
16 32 32 32
signed
signed int
unsigned
unsigned int
unsigned int
long
long int не меньше чем
32
32 32 32 64
long int
signed long
signed long int
unsigned long
unsigned long int
unsigned long int
long long
long long int
(C++11)
не меньше чем
64
64 64 64 64
long long int
signed long long
signed long long int
unsigned long long
unsigned long long int
(C++11)
unsigned long long int

Примечание. Целочисленная арифметика определяется по-разному для целочисленных типов со знаком и без знака. Смотрите арифметические операторы, в частности целочисленные переполнения.

std::size_t это целочисленный тип без знака как результ оператора sizeof , а также sizeof... и оператора alignof (начиная с C++11).

[править] Расширенные целочисленные типы (начиная с C++11)

Расширенные целочисленные типы определяются реализацией. Обратите внимание, что целочисленные типы с фиксированной шириной обычно являются псевдонимами стандартных целочисленных типов.

[править] Логический тип

bool это тип, способный содержать одно из двух значений: true или false. Значение sizeof(bool) определяется реализацией и может отличаться от 1.

[править] Символьные типы

signed char - тип для представления знакового символа.
unsigned char - тип для представления беззнакового символа. Также используется для проверки представлений объектов (сырая память).
char - тип для представления символов, которые могут быть наиболее эффективно обработаны в целевой системе (имеет такое же представление и выравнивание, как signed char или unsigned char, но всегда является отдельным типом). Строки многобайтовых символов используют этот тип для представления кодовых единиц. Для каждого значения типа unsigned char в диапазоне [0255] преобразование значения в char и затем обратно в unsigned char даёт исходное значение. (начиная с C++11). Знаковость char зависит от компилятора и целевой платформы: значения по умолчанию для ARM и PowerPC обычно беззнаковые, значения по умолчанию для x86 и x64 обычно знаковые.
wchar_t - тип для представления широких символов (смотрите широкие строки). Он имеет тот же размер, знаковость и выравнивание, как один из целочисленных типов, но это отдельный тип. На практике он 32-битный и содержит UTF-32 в Linux и многих других системах, отличных от Windows, но в Windows 16-битный и содержит кодовые единицы UTF-16. Стандарт требует, чтобы wchar_t был достаточно большим, чтобы представлять любую поддерживаемую кодовую точку символа. Однако такое требование невозможно выполнить в Windows, поэтому оно считается дефектом и устранено в P2460R2.

char16_t - тип для представления символов UTF-16, который должен быть достаточно большим для представления любой кодовой единицы UTF-16 (16 бит). Он имеет тот же размер, знаковость и выравнивание, что и std::uint_least16_t, но представляет собой отдельный тип.

char32_t - тип для представления символов UTF-32, который должен быть достаточно большим для представления любой кодовой единицы UTF-32 (32 бита). Он имеет тот же размер, знаковость и выравнивание, что и std::uint_least32_t, но представляет собой отдельный тип.
(начиная с C++11)

char8_t - тип для представления символов UTF-8, который должен быть достаточно большим для представления любой кодовой единицы UTF-8 (8 бит). Он имеет тот же размер, знаковость и выравнивание, что и unsigned char (и, следовательно, тот же размер и выравнивание, что и char и signed char), но представляет собой отдельный тип.
(начиная с C++20)

Помимо минимального количества битов, стандарт C++ гарантирует, что

1 == sizeof(char)sizeof(short)sizeof(int)sizeof(long)sizeof(long long).

Примечание: это допускает крайний случай, когда размер байтов составляет 64 бита, все типы (включая char) имеют ширину 64 бита, а sizeof возвращает 1 для любого типа.

[править] Типы с плавающей запятой

[править] Стандартные типы с плавающей запятой

Следующие три типа и их версии с cv-квалификацией все вместе называются стандартными типами с плавающей запятой.

float - тип с плавающей запятой одинарной точности. Соответствует формату IEEE-754 binary32, если поддерживается.
double - тип с плавающей запятой двойной точности. Соответствует формату IEEE-754 binary64, если поддерживается.
long double - тип с плавающей запятой повышенной точности. Соответствует формату IEEE-754 binary128, если поддерживается, в противном случае соответствует IEEE-754 binary64-расширенному формату, если поддерживается, иначе соответствует некоторому расширенному формату с плавающей запятой, отличному от IEEE-754, если его точность лучше, чем binary64, и диапазон не менее хорош как binary64, иначе соответствует формату IEEE-754 binary64.
  • Формат binary128 используется некоторыми реализациями HP-UX, SPARC, MIPS, ARM64 и z/OS.
  • Самый известный IEEE-754 binary64-расширенный формат это 80-битный формат с расширенной точностью. Он используется многими реализациями x86 и x86-64 (заметным исключением является MSVC, который реализует long double в том же формате, что и double, то есть binary64).

[править] Расширенные типы с плавающей запятой (начиная с C++23)

Расширенные типы с плавающей запятой определяются реализацией. Они могут включать типы с плавающей запятой фиксированной ширины.

[править] Свойства

Типы с плавающей запятой могут поддерживать специальные значения:

  • бесконечность (положительная и отрицательная), смотрите INFINITY
  • отрицательный ноль, -0.0. Его сравнение эквивалентно положительному нулю, но имеет смысл в некоторых арифметических операциях, например 1.0/0.0 == INFINITY, но 1.0/-0.0 == -INFINITY), а также для некоторых математических функций, например sqrt(std::complex)
  • не число (NaN - not-a-number), которое не сравнивается ни с чем (включая себя). Множество битовых шаблонов представляют значения NaN, смотрите std::nan, NAN. Обратите внимание, что C++ не обращает особого внимания на сигнализацию NaN, кроме определения его поддержки с помощью std::numeric_limits::has_signaling_NaN, и обрабатывает все NaN скрыто.

Действительные числа с плавающей запятой могут использоваться с арифметическими операторами +, -, / и *, а также с различными математическими функциями из cmath. И встроенные операторы, и библиотечные функции могут вызывать исключения с плавающей запятой и устанавливать errno, как описано в math_errhandling

Выражения с плавающей запятой могут иметь больший диапазон и точность, чем указано их типами, смотрите FLT_EVAL_METHOD. Выражения с плавающей запятой также могут быть сжатыми, то есть вычисляться, как если бы все промежуточные значения имели бесконечный диапазон и точность, смотрите #pragma STDC FP_CONTRACT.

На некоторые операции с числами с плавающей запятой влияет (и модифицирует состояние) среда с плавающей запятой (в первую очередь, направление округления).

Определено неявное преобразование между реальными плавающими типами и целочисленными типами.

Смотрите Ограничения типов с плавающей запятой и std::numeric_limits для получения дополнительных сведений, ограничений и свойств типов с плавающей запятой.

[править] Диапазон значений

В следующей таблице приведены ограничения для обычных числовых представлений.

До C++20 стандарт C++ допускал любое представление целых чисел со знаком, а минимальный гарантированный диапазон N-битных целых чисел со знаком был от -(2N-1
-1)
до +2N-1
-1
(например -127 и 127 для 8-битного типа со знаком), что соответствует ограничениям дополнение до единиц или знак и величина.

Однако все компиляторы C++ используют представление дополнение до двух, и, начиная с C++20, это единственное представление, разрешённое стандартом, с гарантированным диапазоном от -2N-1
до +2N-1
-1
(например -128 и 127 для 8-битного типа со знаком).

8-битные представления дополнения до единицы, знака и величины для char были запрещены с C++11 (через CWG 1759), поскольку кодовая единица UTF-8 со значением 0x80, используемая в строковом литерале UTF-8, должна храниться в объекте элемента char.

Тип Размер в битах Формат Диапазон значений
Приблизительный Точный
символ 8 знаковый от -128 до 127
беззнаковый от 0 до 255
16 UTF-16 от 0 до 65535
32 UTF-32 от 0 до 1114111 (0x10ffff)
целое число 16 знаковое ± 3.27 · 104 от -32768 до 32767
беззнаковое от 0 до 6.55 · 104 от 0 до 65535
32 знаковое ± 2.14 · 109 от -2,147,483,648 до 2,147,483,647
беззнаковое от 0 до 4.29 · 109 от 0 до 4,294,967,295
64 знаковое ± 9.22 · 1018 от -9,223,372,036,854,775,808 до 9,223,372,036,854,775,807
беззнаковое от 0 до 1.84 · 1019 от 0 до 18,446,744,073,709,551,615
двоичное
с плавающей
запятой
32 IEEE-754
  • минимальное денормализованное:
    ± 1.401,298,4 · 10{sup|−45}}
  • минимальное нормализованное:
    ± 1.175,494,3 · 10−38
  • максимальное:
    ± 3.402,823,4 · 1038
  • минимальное денормализованное:
    ±0x1p-149
  • минимальное нормализованное:
    ±0x1p-126
  • максимальное:
    ±0x1.fffffep+127
64 IEEE-754
  • минимальное денормализованное:
    ± 4.940,656,458,412 · 10−324
  • минимальное нормализованное:
    ± 2.225,073,858,507,201,4 · 10−308
  • максимальное:
    ± 1.797,693,134,862,315,7 · 10308
  • минимальное денормализованное:
    ±0x1p-1074
  • минимальное нормализованное:
    ±0x1p-1022
  • максимальное:
    ±0x1.fffffffffffffp+1023
80[примечание 1] x86
  • минимальное денормализованное:
    ± 3.645,199,531,882,474,602,528
     · 10−4951
  • минимальное нормализованное:
    ± 3.362,103,143,112,093,506,263
     · 10−4932
  • максимальное:
    ± 1.189,731,495,357,231,765,021
     · 104932
  • минимальное денормализованное:
    ±0x1p-16445
  • минимальное нормализованное:
    ±0x1p-16382
  • максимальное:
    ±0x1.fffffffffffffffep+16383
128 IEEE-754
  • минимальное денормализованное:
    ± 6.475,175,119,438,025,110,924,
    438,958,227,646,552,5 · 10−4966
  • минимальное нормализованное:
    ± 3.362,103,143,112,093,506,262,
    677,817,321,752,602,6 · 10−4932
  • максимальное:
    ± 1.189,731,495,357,231,765,085,
    759,326,628,007,016,2 · 104932
  • минимальное денормализованное:
    ±0x1p-16494
  • минимальное нормализованное:
    ±0x1p-16382
  • максимальное:
    ±0x1.ffffffffffffffffffffffffffff
    p+16383
  1. Представление объекта обычно занимает 96/128 бит на 32/64-битных платформах соответственно.

Примечание: фактические (в отличие от гарантированного минимума) ограничения на значения, представленные этими типами, доступны в интерфейсе числовых ограничений C и std::numeric_limits

[править] Примечание

Макрос тест функциональности Значение Стандарт Комментарий
__cpp_unicode_characters 200704L (C++11) Новые символьные типы (char16_t и char32_t)
__cpp_char8_t 201811L (C++20) char8_t
202207L (C++23) исправление совместимости и переносимости char8_t (разрешить инициализацию массивов (unsigned) char строковыми литералами UTF-8)

[править] Ключевые слова

void, bool, true, false, char, wchar_t, char8_t, char16_t, char32_t, int, short, long, signed, unsigned, float, double

[править] Отчёты о дефектах

Следующие изменения поведения были применены с обратной силой к ранее опубликованным стандартам C++:

Номер Применён Поведение в стандарте Корректное поведение
CWG 238 C++98 ограничения, наложенные на реализацию с плавающей запятой, не были указаны указано как отсутствие ограничения
CWG 1759 c++11 char не гарантирует, что он сможет представлять кодовую единицу UTF-8 0x80 гарантирует
WG не указан C++98 wchar_t требовалось, чтобы иметь возможность представлять разные коды для всех элементов самого большого расширенного набора символов, указанного среди поддерживаемых локалей не требуется

[править] Смотрите также

Документация C по арифметические типы