Type

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

Классификация типов

Система типов C++ состоит из следующих типов:

• фундаментальные типы (см. также std::is_fundamental ):

• тип void (см. также std::is_void );

• арифметические типы (см. также std::is_arithmetic ):

• целочисленные типы (включая cv-квалифицированные версии , см. также std::is_integral , синонимом целочисленного типа является integer type):

• тип bool ;
• символьные типы:

• типы узких символов:

• обычные символьные типы: char , signed char , unsigned char ^[1]

• типы широких символов: char16_t , char32_t , (начиная с C++11) wchar_t ;

• знаковые целочисленные типы:

• стандартные знаковые целочисленные типы: signed char , short , int , long , long long ;

• беззнаковые целочисленные типы:

• стандартные беззнаковые целочисленные типы: unsigned char , unsigned short , unsigned , unsigned long , unsigned long long ;

• типы с плавающей запятой (см. также std::is_floating_point ):

• стандартные типы с плавающей запятой: float , double , long double и их cv-квалифицированные версии ;

• составные типы (см. также std::is_compound ):

• типы ссылок (см. также std::is_reference ):

• типы lvalue-ссылок (см. также std::is_lvalue_reference ):

• lvalue-ссылки на объектные типы;
• lvalue-ссылки на функциональные типы;

• типы указателей (см. также std::is_pointer ):

• типы указателей на объекты ;
• типы указателей на функции ;

• типы указателей на члены (см. также std::is_member_pointer ):

• типы указателей на члены-данные (см. также std::is_member_object_pointer );
• типы указателей на члены-функции (см. также std::is_member_function_pointer );

• типы массивов (см. также std::is_array );
• типы функций (см. также std::is_function );
• типы перечислений (см. также std::is_enum );

• типы неограниченных перечислений ;

• class types :

• non-union types (см. также std::is_class );
• union types (см. также std::is_union ).

1. ↑ signed char и unsigned char являются типами узких символов, но они не являются символьными типами. Другими словами, множество типов узких символов не является подмножеством множества символьных типов.

Для каждого неквалифицированного по cv типа, кроме ссылки и функции, система типов поддерживает три дополнительные cv-квалифицированные версии этого типа ( const , volatile и const volatile ).

Другие категории

Тип объекта (см. также std::is_object ) — это (возможно, cv-квалифицированный) тип, который не является типом функции, не является ссылочным типом и не является (возможно, cv-квалифицированным) void .

Следующие типы в совокупности называются скалярными типами (см. также std::is_scalar ):

• арифметические типы
• типы перечислений
• типы указателей
• типы указателей на члены

• cv-квалифицированные версии этих типов

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

• скалярные типы
• классы неявного времени жизни
• массивы
• cv-квалифицированные версии этих типов

Устаревшие категории

Пользовательский тип данных

Программно-определенная специализация — это явная специализация или частичная специализация , которая не является частью стандартной библиотеки C++ и не определена реализацией.

A program-defined type — это один из следующих типов:

• A non- closure (since C++11) class type или enumeration type который не является частью стандартной библиотеки C++ и не определён реализацией.

• Создание экземпляра специализации, определённой в программе.

Наименование типов

Имя name может быть объявлено для ссылки на тип с помощью:

• class объявление;
• union объявление;
• enum объявление;
• typedef объявление;
• type alias объявление.

Типы, которые не имеют имён, часто требуют упоминания в программах на C++; синтаксис для этого известен как type-id . Синтаксис type-id, который именует тип T , в точности соответствует синтаксису объявления переменной или функции типа T , с опущенным идентификатором, за исключением того, что decl-specifier-seq в грамматике объявления ограничивается type-specifier-seq , и что новые типы могут быть определены только если type-id появляется в правой части объявления псевдонима нетемплейтного типа.

int* p;               // объявление указателя на int
static_cast<int*>(p); // type-id это "int*"
int a[3];   // объявление массива из 3 int
new int[3]; // type-id это "int[3]" (называется new-type-id)
int (*(*x[2])())[3];      // объявление массива из 2 указателей на функции
                          // возвращающие указатель на массив из 3 int
new (int (*(*[2])())[3]); // type-id это "int (*(*[2])())[3]"
void f(int);                    // объявление функции принимающей int и возвращающей void
std::function<void(int)> x = f; // параметр шаблона типа это type-id "void(int)"
std::function<auto(int) -> void> y = f; // то же самое
std::vector<int> v;       // объявление вектора int
sizeof(std::vector<int>); // type-id это "std::vector<int>"
struct { int x; } b;         // создает новый тип и объявляет объект b этого типа
sizeof(struct { int x; });   // ошибка: нельзя определять новые типы в выражении sizeof
using t = struct { int x; }; // создает новый тип и объявляет t как псевдоним этого типа
sizeof(static int); // ошибка: спецификаторы класса хранения не являются частью type-specifier-seq
std::function<inline void(int)> f; // ошибка: спецификаторы функций также не входят

Часть декларатора в грамматике объявлений с удалённым именем называется абстрактным-декларатором .

Type-id может использоваться в следующих ситуациях:

• для указания целевого типа в выражениях приведения ;
• в качестве аргументов для sizeof , alignof , alignas , new , и typeid ;
• в правой части объявления псевдонима типа ;
• в качестве завершающего возвращаемого типа в объявлении функции ;
• в качестве аргумента по умолчанию для шаблонного параметра типа ;
• в качестве шаблонного аргумента для шаблонного параметра типа ;

Type-id может использоваться с некоторыми модификациями в следующих ситуациях:

• в списке параметров функции (когда имя параметра опущено), type-id использует decl-specifier-seq вместо type-specifier-seq (в частности, разрешены некоторые спецификаторы класса хранения);
• в имени пользовательской функции преобразования , абстрактный декларатор не может включать операторы функции или массива.

Уточняющий спецификатор типа

Уточненные спецификаторы типа могут использоваться для ссылки на ранее объявленное имя класса (class, struct или union) или на ранее объявленное имя перечисления, даже если имя было скрыто не-типовым объявлением . Они также могут использоваться для объявления новых имен классов.

См. elaborated type specifier для получения подробной информации.

Статический тип

Тип выражения, который определяется в результате анализа программы на этапе компиляции, называется статическим типом выражения. Статический тип не изменяется во время выполнения программы.

Динамический тип

Если некоторое glvalue выражение ссылается на полиморфный объект , тип его наиболее производного объекта называется динамическим типом.

// дано
struct B { virtual ~B() {} }; // полиморфный тип
struct D : B {};               // полиморфный тип
D d; // самый производный объект
B* ptr = &d;
// статический тип (*ptr) - B
// динамический тип (*ptr) - D

Для выражений prvalue динамический тип всегда совпадает со статическим типом.

Неполный тип

Следующие типы являются неполными типами :

• тип void (возможно cv -квалифицированный);
• неполноопределенные объектные типы :
  • классовый тип, который был объявлен (например, с помощью forward declaration ), но не определен;
  • array of unknown bound ;
  • массив элементов неполного типа;
  • enumeration type от точки объявления до момента определения его базового типа.

Все остальные типы являются полными.

Любой из следующих контекстов требует, чтобы тип T был полным:

• определение или вызов функции с возвращаемым типом T или типом аргумента T ;
• определение объекта типа T ;
• объявление нестатического члена класса типа T ;
• new выражение для объекта типа T или массива с типом элементов T ;
• преобразование lvalue в rvalue , примененное к glvalue типа T ;
• неявное или явное преобразование к типу T ;
• стандартное преобразование , dynamic_cast , или static_cast к типу T * или T & , за исключением преобразования из нулевого указателя-константы или из указателя на возможно cv-квалифицированный void ;
• оператор доступа к члену класса , примененный к выражению типа T ;
• typeid , sizeof , или alignof оператор, примененный к типу T ;
• арифметический оператор , примененный к указателю на T ;
• определение класса с базовым классом T ;
• присваивание lvalue типа T ;
• обработчик исключения типа T , T & , или T * .

(В общем случае, когда размер и расположение T должны быть известны.)

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

Неполностью определённый тип объекта может быть завершён:

• Тип класса (такой как class X ) может считаться неполным в одной точке единицы трансляции и считаться полным позже; тип class X является одним и тем же типом в обеих точках:

struct X;            // объявление X, определение пока не предоставлено
extern X* xp;        // xp - указатель на неполный тип:
                     // определение X недоступно
void foo()
{
    xp++;            // некорректно: X неполный
}
struct X { int i; }; // определение X
X x;                 // OK: определение X доступно
void bar()
{
    xp = &x;         // OK: тип "указатель на X"
    xp++;            // OK: X полный
}

• Объявленный тип массива может быть массивом незавершенного типа класса и, следовательно, незавершенным; если тип класса завершается позже в единице трансляции, тип массива становится завершенным; тип массива в этих двух точках является одним и тем же типом.
• Объявленный тип массива может быть массивом неизвестной границы и, следовательно, быть незавершенным в одной точке единицы трансляции и завершенным позже; типы массивов в этих двух точках ("массив неизвестной границы T " и "массив N T ") являются разными типами.

Тип указателя или ссылки на массив неизвестной границы постоянно указывает на или ссылается на неполный тип. Массив неизвестной границы, именованный с помощью typedef объявления, постоянно ссылается на неполный тип. В любом случае тип массива не может быть завершён:

extern int arr[];   // тип arr является неполным
typedef int UNKA[]; // UNKA является неполным типом
UNKA* arrp;         // arrp - указатель на неполный тип
UNKA** arrpp;
void foo()
{
    arrp++;         // ошибка: UNKA является неполным типом
    arrpp++;        // OK: размер UNKA* известен
}
int arr[10];        // теперь тип arr является полным
void bar()
{
    arrp = &arr;    // OK: преобразование квалификации (начиная с C++20)
    arrp++;         // ошибка: UNKA не может быть завершен
}

Отчеты о дефектах

Следующие отчеты об изменениях поведения, влияющие на дефекты, были применены задним числом к ранее опубликованным стандартам C++.

Ссылки

Смотрите также

Внешние ссылки