Спецификаторы типа заполнителя (начиная с C++11)

 

C++

Поддержка компилятором

Автономные и размещённые реализации

Язык

Стандартная библиотека

Заголовки стандартной библиотеки

Требования к именованию

Макросы тестирования функциональности (C++20)

Поддержка языка

Библиотека концептов(C++20)

Библиотека метапрограммирования(C++11)

Библиотека диагностики

Библиотека общих утилит

Библиотека строк

Библиотека контейнеров

Библиотека итераторов

Библиотека диапазонов(C++20)

Библиотека алгоритмов

Библиотека численных данных

Библиотека ввода/вывода

Библиотека локализаций

Регулярные выражения(C++11)

Атомарные операции(C++11)

Библиотека поддержки конкуренции(C++11)

Библиотека файловой системы(C++17)

Технические спецификации

Указатель символов

Внешние библиотеки

 

Язык С++

Общие темы
Препроцессор Комментарии	Ключевые слова Управляющие последовательности
Управление потоком
Операторы условного выполнения
if	switch
Операторы итерации (циклы)
for диапазонный for(C++11)	while do-while
Операторы перехода
continue - break	goto - return
Функции
Объявление функции
Выражение лямбда-функции
Спецификатор inline
Спецификации динамических исключений(до C++17*)
Спецификатор noexcept(C++11)
Исключения
Выражение throw	Блок try-catch
Пространства имён
Объявление пространства имён	Псевдонимы пространств имён
Типы
Основные типы Типы перечислений Типы функций	Типы классов/структур Типы объединений
Спецификаторы
decltype(C++11) auto(C++11) alignas(C++11)	const/volatile constexpr(C++11)
Спецификаторы длительности хранения
Инициализация
Инициализация по умолчанию Инициализация значением Инициализация нулём Инициализация копированием Прямая инициализация	Агрегатная инициализация     Инициализация списком(C++11) Константная инициализация Инициализация ссылки

Выражения
Категории значений Порядок оценки	Операторы Приоритет оператора
Альтернативные представления
Литералы
Логические - Целочисленные - С плавающей запятой
Символьные - Строковые - nullptr(C++11)
Определяемые пользователем(C++11)
Утилиты
Атрибуты(C++11)
Types
Объявление typedef
Объявление псевдонима типа(C++11)
Casts
Неявные преобразования - Явные преобразования
static_cast - dynamic_cast
const_cast - reinterpret_cast
Выделение памяти
Выражение new	Выражение delete
Классы
Объявление класса Конструкторы Указатель this	Спецификаторы доступа Спецификатор friend
Свойства функции класса
Виртуальная функция Спецификатор override(C++11)       Спецификатор final(C++11)	explicit(C++11) static
Специальные функции-элементы
Конструктор по умолчанию Конструктор копирования Конструктор перемещения(C++11)	Присваивание копированием Присваивание перемещением(C++11) Деструктор
Шаблоны
Шаблон класса Шаблон функции	Специализация шаблона Пакеты параметров(C++11)
Разное
Встроенный ассемблер	История C++

 

Обьявления

Обзор синтаксис объявления последовательность-спецификаторов-объявления объявление Спецификаторы typedef inline спецификатор функции virtual спецификатор функции explicit friend constexpr (C++11) consteval (C++20) спецификатор класса памяти classstruct union enum decltype (C++11) auto (C++11) alignas (C++11) constvolatile спецификатор полного типа атрибуты (C++11)

Объявления ссылка указатель массив Block declarations простое объявление → объявление структурных привязок(C++17) объявление псевдонимов(C++11) объявление псевдонимов пространств имён using-declaration директива using объявление static_assert(C++11) определение asm объявление непрозрачного enum(C++11) Другие объявления определение пространств имён объявление функции объявление шаблона класса объявление шаблона функции явное инстанцирование шаблона(C++11) явная специализация шаблона спецификация связывания объявление атрибута(C++11) пустое объявление

 

Для переменных указывает, что тип объявляемой переменной будет автоматически выведен из её инициализатора.

Для функций указывает, что тип возвращаемого значения будет выведен из их операторов return.

(начиная с C++14)

Для параметров шаблона, не относящихся к типу, указывает, что тип будет выведен из аргумента.

(начиная с C++17)

Синтаксис

ограничение-типа (необязательно)auto	(1)	(начиная с C++11)
ограничение-типа (необязательно)decltype(auto)	(2)	(начиная с C++14)

ограничение-типа

—

(начиная с C++20) имя концепта, необязательно уточнённое, за которым может следовать список аргументов шаблона, заключённый в <>

1) тип выводится с использованием правил для вывода аргумента шаблона.

2) тип decltype(выражение), где выражение это инициализатор или то, что используется в операторах возврата.

Заполнитель auto может сопровождаться модификаторами, такими как const или &, которые будут участвовать в выводе типа. Заполнитель decltype(auto) должен быть единственным компонентом объявленного типа.(начиная с C++14)

Объяснение

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

• в последовательности спецификатора типа переменной: auto x = выражение; в качестве спецификатора типа. Тип выводится из инициализатора.
  Если спецификатором типа заполнителя является autoили ограничение-типаauto(начиная с C++20), тип переменной выводится из инициализатора с использованием правил для вывода аргумента шаблона из вызова функции (для подробностей смотрите вывод аргумента шаблона — другие контексты).
  Например, при данном constauto& i = выражение;, тип i в точности совпадёт с типом аргумента u в воображаемом шаблоне template<class U>void f(const U& u), если вызов функции f(выражение) был скомпилирован. Следовательно, auto&& может быть выведено либо как ссылка lvalue, либо как ссылка rvalue в соответствии с инициализатором, который используется в цикле for на основе диапазона.
  

  Если спецификатор типа заполнителя имеет вид decltype(auto)или ограничение-типаdecltype(auto)(начиная с C++20), выведенный тип это decltype(выражение), где выражение это инициализатор.

  (начиная с C++14)

  Если спецификатор типа заполнителя используется для объявления нескольких переменных, выведенные типы должны совпадать. Например, объявление auto i =0, d =0.0; некорректно, а объявление auto i =0, *p =&i; правильно и auto выводится как int.

• в идентификаторе типа выражения new. Тип выводится из инициализатора. Для new Tинициализатор (где T содержит тип-заполнитель, инициализатор является либо инициализатором в скобках, либо списком инициализаторов в фигурных скобках), тип T выводится, как для переменной x в придуманном объявлении T x инициализатор;.
• (начиная с C++14) в возвращаемом типе функции или лямбда-выражения: auto& f();. Тип возвращаемого значения выводится из операнда не отброшенного(начиная с C++17)оператора return.
  Смотрите функция — вывод типа возвращаемого значения.
• (начиная с C++17) в объявлении параметра шаблона не типа: template<auto I>struct A;. Его тип выводится из соответствующего аргумента.

Спецификатор auto может также появляться в спецификаторе простого типа явного преобразование типа: auto(выражение) и auto{выражение}. Его тип выводится из выражения.

(начиная с C++23)

Кроме того, autoи ограничение-типаauto(начиная с C++20) может появляться в: объявлении параметра лямбда-выражения: [](auto&&){}. Такое лямбда-выражение является общим лямбда-выражением. (начиная с C++20)объявлении параметра функции: void f(auto);. Объявление функции вводит сокращённый шаблон функции.

(начиная с C++14)

Ограничение типа Если присутствует ограничение-типа, пусть T будет типом, выведенным для заполнителя, ограничение-типа вводит выражение ограничения следующим образом: Если ограничение-типа это Concept<A1, ..., An>, то выражение ограничения имеет вид Concept<T, A1, ..., An>; иначе (ограничение-типа это Concept без списка аргументов), выражением ограничения является Concept<T>. Вывод невозможен, если выражение ограничения недопустимо или возвращает false.

(начиная с C++20)

Примечание

До C++11, auto имел семантику спецификатора длительности хранения.

Смешивание auto переменных и функций в одном объявлении, как в auto f()->int, i =0; не допускается.

Спецификатор auto также может использоваться с декларатором функции, за которым следует конечный возвращаемый тип, и в этом случае объявленный возвращаемый тип является завершающим возвращаемым типом (который также может быть типом-заполнителем).

auto(*p)()->int;// объявляет p как указатель на функцию, возвращающую intauto(*q)()->auto= p;// объявляет q как указатель на функцию, возвращающую T,// где T выводится из типа p

Спецификатор auto также может использоваться в объявлении структурной привязки.

(начиная с C++17)

Ключевое слово auto также может использоваться в спецификаторе-вложенного-имени. Спецификатор-вложенного-имени в форме auto:: это заполнитель, который заменяется классом или типом перечисления в соответствии с правилами вывода заполнителя ограниченного типа.

(ТС концепций)

Макрос Тестирования функциональности	Значение	Стандарт	Функциональность
__cpp_decltype_auto	201304L	(C++14)	decltype(auto)

Пример

Запустить этот код

#include <iostream>#include <utility>   template<class T, class U>auto add(T t, U u){return t + u;}// возвращаемый тип это тип operator+(T, U)   // идеальная переадресация вызова функции должна использовать decltype(auto)// в случае, если вызываемая функция возвращает по ссылкеtemplate<class F, class... Args> decltype(auto) PerfectForward(F fun, Args&&... args){return fun(std::forward<Args>(args)...);}   template<auto n>// Автоматическое объявление параметра C++17auto f()->std::pair<decltype(n), decltype(n)>// auto не может вывести из списка// инициализации в скобках{return{n, n};}   int main(){auto a =1+2;// тип a равен intauto b = add(1, 1.2);// тип b равен double static_assert(std::is_same_v<decltype(a), int>); static_assert(std::is_same_v<decltype(b), double>);   auto c0 = a;// тип c0 равен int, содержит копию a decltype(auto) c1 = a;// тип c1 равен int, содержит копию a decltype(auto) c2 =(a);// тип c2 равен int&, псевдоним astd::cout<<"до модификации через c2, a = "<< a <<'\n';++c2;std::cout<<" после модификации через c2, a = "<< a <<'\n';   auto[v, w]= f<0>();//объявление структурной привязки   auto d ={1, 2};// OK: тип d это std::initializer_list<int>auto n ={5};// OK: тип n это std::initializer_list<int>// auto e{1, 2}; // Ошибка начиная с DR n3922, std::initializer_list<int> передauto m{5};// OK: тип m это int начиная с DR n3922, initializer_list<int> перед// decltype(auto) z = { 1, 2 } // Ошибка: {1, 2} не является выражением   // auto обычно используется для безымянных типов, таких как типы лямбда-выраженияauto lambda =[](int x){return x +3;};   // auto int x; // правильно C++98, ошибка с C++11// auto x; // правильно C, ошибка в C++   [](...){}(c0, c1, v, w, d, n, m, lambda);// подавляет предупреждения о// "неиспользуемой переменной"}

Возможный вывод:

до модификации через c2, a = 3 после модификации через c2, a = 4

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

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

Номер	Применён	Поведение в стандарте	Корректное поведение
CWG 1265	C++11	спецификатор auto можно использовать для объявления функции с конечным возвращаемым типом и определения переменной в одном операторе объявления	запрещено
CWG 1346	C++11	список выражений в скобках не может быть присвоен автоматической переменной	разрешено
CWG 1347	C++11	объявление со спецификатором auto может определять две переменные с типами T и std::initializer_list<T> соответственно	запрещено
CWG 1852	C++14	спецификатор auto в decltype(auto) также был заполнителем	не заполнитель в данном случае