Русская Википедия:C++20
Шаблон:Style C++20 — название стандарта ISO/IEC языка программирования C++. Спецификация опубликована в декабре 2020 года[1].
Комитет по стандартам C++ начал планировать C++20 в июле 2017 года[2]. C++20 является преемником C++17.
Константа Шаблон:Cpp увеличилась до Шаблон:Cpp.
Запрещены и удалены
Запрещены операции с volatile
Так как модификатор Шаблон:Cpp является машинозависимым и семантика операций над ним и количество обращений к памяти не ясны, для межпоточной синхронизации лучше использовать Шаблон:Cpp.
Запрещены следующие операции с Шаблон:Cpp-переменными[3]:
- операции Шаблон:Cpp, Шаблон:Cpp;
- операции Шаблон:Cpp и другие (снят в C++23);
- цепочки присваиваний;
- функции, параметры и возвращаемые значения с модификатором
volatile
; - все функции STL, связанные с
volatile
, кроме некоторых вродеremove_volatile
;
Для atomic
добавлены дополнительные функции, компенсирующие то, что запретили.
Удалена агрегатная инициализация при наличии пользовательского конструктора
В предыдущих стандартах агрегатная инициализация разрешалась, если конструктор был помечен как Шаблон:Cpp или Шаблон:Cpp, что вводило пользователей в заблуждение: объект инициализируется в обход конструктора.
struct X {
int a = 0;
X() = default;
};
X x { 5 }; // Си++17: OK
// Си++20: no matching constructor for initialization of 'X'
Удалены запреты из C++17
Удалены редкие возможности стандартной библиотеки, запрещённые в C++17:[4][5][6]
allocator<void>
— оказался невостребованным;- часть функций
allocator
— дублируется шаблономallocator_traits
; raw_storage_iterator
— не вызывает конструкторов и потому ограничен по применению;get_temporary_buffer
— имеет неочевидные подводные камни;is_literal_type
— бесполезен для обобщённого кода;- Шаблон:Cpp — из-за ненадёжности в многопоточной среде; если очень надо, используйте Шаблон:Cpp;
result_of
— заменён наinvoke_result
;uncaught_exception()
— заменён наuncaught_exceptions
.- Шаблон:Cpp — не имеют смысла в Си++. Шаблон:Cpp и прочие оставили для совместимости с Си.
Из языка удалили ремарку Шаблон:Cpp, которую ещё в Си++11 заменили на Шаблон:Cpp. Если нужна совместимость с Си++03, в заголовках совместимости нужно прописывать что-то вроде
#if __cplusplus < 201103L
#define noexcept throw()
#endif
Оставили:
codecvt
— на поверку работал очень плохо, комитет призвал пользоваться специализированными библиотеками.iterator
— проще писать итераторы с нуля, чем основываться на нём.- потоки Шаблон:Cpp — непонятно, что взамен.
- неявное создание операции «присвоить», если есть конструктор копирования и деструктор (а также конструктора копирования, если есть присваивание и деструктор) — библиотека всё ещё полагается на это поведение.
Прочие запреты из языка
- Неявный перехват Шаблон:Cpp в лямбда-функциях Шаблон:Cpp — из-за неясной семантики. Существует Шаблон:Cpp для перехвата по указателю и Шаблон:Cpp для перехвата по копии.
- Операция «запятая» в индексах Шаблон:Cpp для любых a, b и c — из-за неочевидного поведения и желания создать новый синтаксис для многомерных массивов[7]. Если очень нужно, пишите Шаблон:Cpp.
- Неявные преобразования в перечисляемый тип — для более прогнозируемого поведения новой операции «звездолёт» (Шаблон:Cpp, трёхзначное сравнение).
- Сравнение двух массивов — для более прогнозируемого поведения новой операции «звездолёт» (Шаблон:Cpp, трёхзначное сравнение). Хотя бы один надо преобразовать в указатель.
Прочие запреты из библиотеки
- Шаблон:Cpp — вместо сложного понятия «простая структура данных» лучше использовать конкретные свойства типа: тривиально строится, тривиально уничтожается и т. д. Если очень надо (например, для передачи данных между плагинами), эквивалентно Шаблон:Cpp.
- Шаблон:Cpp — новая операция «звездолёт» делает это лучше.
- атомарные возможности Шаблон:Cpp — непонятно, как работать с указателем, атомарно или нет. Лучше это определить системой типов, Шаблон:Cpp.
- Шаблон:Cpp — теперь решили, что Шаблон:Cpp не будет уменьшать ёмкость.
- Шаблон:Cpp — теперь Шаблон:Cpp отличается от Шаблон:Cpp.
- Шаблон:Cpp — теперь это делает шаблонный конструктор Шаблон:Cpp.
Язык
Мелкие изменения
- Добавлен беззнаковый тип char8_t, способный содержать единицы UTF-8.
- Шаблон:Cpp, позволяющий сделать код в ключевых местах менее загромождённым.
- Дополнительная инициализация в for по объекту: Шаблон:Cpp[8]. Если возвращаемый Шаблон:Cpp объект временный, его срок жизни расширяется на весь цикл, но другие временные объекты благополучно исчезают, и если временный на поверку f(), запись Шаблон:Cpp ошибочная.
Модули
Директива компилятора Шаблон:Cpp в своё время была удобным механизмом Си, который, был, по сути, кроссплатформенным ассемблером, «паразитировавшим» на ассемблерных утилитах — линкере и библиотекаре. Отсюда важная черта компиляторов Си — они первыми после ассемблера появлялись на новых платформах. Но с расширением проектов квадратично повышалось время их компиляции: увеличивалось как количество единиц трансляции, так и количество подключённых к ним заголовков. Механизм модулей был долгим объектом споров ещё со времён Си++11.
В Си++20 он вошёл в таком виде[9]:
// helloworld.cpp
export module helloworld; // module declaration
import <iostream>; // import declaration
export void hello() { // export declaration
std::cout << "Hello world!\n";
}
Сопрограммы
Сопрограмма — это специальная бесстековая функция, которая может приостановить своё исполнение, пока выполняется другая функция[10]. Состояние сопрограммы хранится в динамической памяти (кроме случаев, когда оптимизатору удалось избавиться от выделения). Выглядит как обычная функция, но содержит особые сопрограммные ключевые слова Шаблон:Cpp.
task<> tcp_echo_server() {
char data[1024];
for (;;) {
size_t n = co_await socket.async_read_some(buffer(data));
co_await async_write(socket, buffer(data, n));
}
}
Физически сопрограмма — это функция, возвращающая свежесозданный объект-обещание. Каждый раз, когда пользователь делает что-то с объектом-обещанием, управление передаётся коду сопрограммы. В библиотеке доступны несколько стандартных обещаний — например, Шаблон:Cpp обеспечивает ленивое вычисление.
typename объявлен излишним там, где допустим только тип
В некоторых местах шаблонов слово Шаблон:Cpp (объяснение, что Шаблон:Cpp — это тип, а не функция) больше не требуется[11]. К таким местам относятся…
- тип после Шаблон:Cpp — Шаблон:Cpp
- тип в Шаблон:Cpp — Шаблон:Cpp
- заключительный возвращаемый тип Шаблон:Cpp;
- тип по умолчанию в шаблоне Шаблон:Cpp
- тип в static_cast, const_cast, reinterpret_cast, dynamic_cast — Шаблон:Cpp
- тип переменной/функции в пространстве имён (в том числе в глобальном) или классе — Шаблон:Cpp
- тип параметра функции/шаблона, если есть идентификатор (кроме выражений, связанных с вычислением значения параметра по умолчанию) — Шаблон:Cpp
template<class T> T::R f(); // Теперь OK, тип в глобальном пространстве имён
template<class T> void f(T::R); // Нужен typename, без него это попытка создания void-переменной, инициализированной T::R
template<class T> struct S {
using Ptr = PtrTraits<T>::Ptr; // Теперь OK, тип в using
T::R f(T::P p) { // Теперь OK, тип в классе
return static_cast<T::R>(p); // Теперь OK, static_cast
}
auto g() -> S<T*>::Ptr; // Теперь OK, заключительный возвращаемый тип
};
template<typename T> void f() {
void (*pf)(T::X); // Остаётся OK, переменная типа void*, инициализированная T::X
void g(T::X); // Нужен typename, без него это попытка создания void-переменной, инициализированной T::X
}
Вычисление размера массива в new
Размер массива в операторе new теперь дедуктируется автоматически[12]
double a[]{1,2,3}; // Остаётся OK
double* p = new double[]{1,2,3}; // Теперь OK
Новые атрибуты
- Шаблон:Cpp — переменная без данных может не занимать места, а в «дырах» переменной с данными можно держать другие переменные. Но: переменные одного типа никогда не могут находиться по одному адресу.
template <class Allocator> class Storage { private: [[no_unique_address]] Allocator alloc; };
- Шаблон:Cpp — расширение одноимённого атрибута Си++17. Указывает, что возвращаемое функцией значение нельзя игнорировать, и выводит причину.
class XmlReader { // считыватель XML потокового типа public: [[nodiscard("Проверьте результат или используйте requireTag")]] bool getTag(const char* name); void requireTag(const char* name) { if (!getTag(name)) throw std::logic_error(std::string("requireTag: ") + name + " not found"); } };
- Шаблон:Cpp — отмечают, под какие ветви надо оптимизировать программу для лучшей работы предсказателя переходов. Эта методика фактически уже реализована в некоторых компиляторах, см. например
__builtin_expect
в GCC.
if (x > y) [[unlikely]] { std::cout << "Редко случается" << std::endl; } else [[likely]] { std::cout << "Часто случается" << std::endl; }
Расширен constexpr
В constexpr разрешено:
- вызывать виртуальные функции[13];
- вызывать деструкторы, которые тоже должны быть Шаблон:Cpp;
- работать с Шаблон:Cpp[14];
- работать с Шаблон:Cpp — блок перехвата ничего не делает, а выброс исключения в таком контексте, как и раньше, вычислит функцию при исполнении[15];
- использовать Шаблон:Cpp и Шаблон:Cpp[16];
- Шаблон:Cpp, с некоторыми ограничениями[17];
- Шаблон:Cpp, если тот не вызывается при компиляции;
- неинициализированные переменные.
Подобная конструкция в теории позволит, например, делать, чтобы константный std::vector просто указывал на память соответствующего std::initializer_list, а обычный неконстантный — отводил динамическую память.
Расширен вызов лямбда-функций при компиляции — например, можно отсортировать std::tuple.
Ключевые слова consteval и constinit
constexpr-код не обязан вызываться при компиляции, и достаточно написать Шаблон:Cpp, чтобы constexpr-цепочка оборвалась на конструкторе std::set и произошла инициализация при выполнении. Иногда это нежелательно — если переменная используется при инициализации программы (известный недостаток Си++ — неконтролируемый порядок инициализации CPP-файлов), большая (например, большая таблица) или трудновычисляемая (инициализация той же таблицы, проводящаяся за O(n²)). И у программистов бывает просто спортивный интерес перенести код в компиляцию. Чтобы дать уверенность, используются два новых ключевых слова:
- Шаблон:Cpp в функциях: требует, чтобы функция выполнялась при компиляции. Вызов из контекста, невыполнимого при компиляции, запрещён. В заголовках совместимости со старыми компиляторами заменяется на Шаблон:Cpp.
- Шаблон:Cpp в переменной: требует, чтобы переменная вычислилась при компиляции. В заголовках совместимости со старыми компиляторами заменяется на пустую строку.
consteval int sqr(int n)
{ return n * n; }
constinit const auto res2 = sqr(5);
int main()
{
int n;
std::cin >> n;
std::cout << sqr(n) << std::endl; // ошибка, невычислимо при компиляции
}
explicit (bool)
Ключевое слово Шаблон:Cpp можно писать вместе с константным булевским выражением: если оно истинно, преобразование возможно только явно. Упрощает метапрограммирование, заменяет идиому SFINAE[18].
// Было, std::forward опущен для краткости
template<class T> struct Wrapper {
template<class U, std::enable_if_t<std::is_convertible_v<U, T>>* = nullptr>
Wrapper(U const& u) : t_(u) {}
template<class U, std::enable_if_t<!std::is_convertible_v<U, T>>* = nullptr>
explicit Wrapper(U const& u) : t_(u) {}
T t_;
};
// Стало
template<class T> struct Wrapper {
template<class U>
explicit(!std::is_convertible_v<U, T>)
Wrapper(U const& u) : t_(u) {}
T t_;
};
Трёхзначное сравнение («звездолёт»)
Операция Шаблон:Cpp позволяет сравнивать объекты по одному из трёх методов:
- Частичный порядок: меньше, эквивалентны, больше, несравнимы.
- Слабый порядок: меньше, эквивалентны, больше. Может случиться, что у эквивалентных объектов значение какого-то общедоступного поля или функции может разниться. Понятие «эквивалентны» транзитивно.
- Сильный (линейный) порядок (меньше, равны, больше). Равные объекты различимы разве что по адресу.
class PersonInFamilyTree { // ...
public:
std::partial_ordering operator<=>(const PersonInFamilyTree& that) const {
if (this->is_the_same_person_as ( that)) return partial_ordering::equivalent;
if (this->is_transitive_child_of( that)) return partial_ordering::less;
if (that. is_transitive_child_of(*this)) return partial_ordering::greater;
return partial_ordering::unordered;
}
};
Название «звездолёт» произошло из старой игры по «Звёздному пути» — этими тремя символами обозначался «Энтерпрайз».
Версия операции «звездолёт» с телом Шаблон:Cpp просто сравнивает все поля в порядке объявления. Также возможна операция «равняется» с телом Шаблон:Cpp, она также сравнивает все поля в порядке объявления и автоматически объявляет операцию «не равняется»[19].
Концепции
Шаблон:Main Концепция — требования к параметрам шаблона, чтобы этот шаблон имел смысл. Большую часть жизни Си++ концепция описывалась устно, со сложными ошибками в заведомо действующих заголовках вроде STL, если программист не вписался в концепцию. Если же программист сам пишет шаблон, он может случайно выйти из концепции и не увидеть это на тестовой программе, ведь простейшие типы вроде Шаблон:Cpp имеют множество функций по умолчанию вроде конструктора копирования, присваивания, арифметических операций.
template <class T>
concept bool EqualityComparable() {
return requires(T a, T b) {
{a == b} -> Boolean; // Концепция, означающая тип, преобразуемый в boolean
{a != b} -> Boolean;
};
}
Строковые константы как параметры шаблона
Обработка строк при компиляции была давней мечтой Си++, и очередной шажок к ней — строковые константы в шаблонах[20]. В частности, хотелось бы преобразовывать регулярные выражения в байт-код уже при компиляции. На экспериментальных библиотеках регулярных выражений уже видели ускорение до 3000 раз по сравнению с std::regex.
template <auto& str>
void f() {
// str = char const (&)[7]
}
f<"foobar">();
Именованная инициализация структур
Порядковая инициализация структур Си Шаблон:Cpp ошибкоопасна, если ожидается расширение структуры или два соседних элемента можно спутать. В новый стандарт добавилось Шаблон:Cpp, давно существовавшее в Си, но не формализированное в Си++[21].
Кроме того, такая конструкция позволяет инициализировать именно тот вариант Шаблон:Cpp, который нужно.
union FloatInt {
float asFloat;
int32_t asInt;
};
FloatInt x { .asInt = 42 };
Удалены по сравнению с Си:
- именованная инициализация массивов Шаблон:Cpp — начиная с Си++11 квадратные скобки в начале выражения означают лямбда-функцию.
- объявление не по порядку Шаблон:Cpp — конфликтует с автодеструкторами Си++: сконструировали в одном порядке, разрушили в другом?
- именованная инициализация элементов вложенной структуры Шаблон:Cpp — редко используются
- смешение именованной и порядковой инициализации: Шаблон:Cpp
Изменения в лямбда-функциях
Лямбда-функции появились в Си++11 вдогонку за другими языками программирования. Решают сразу несколько вопросов: заменяют препроцессор, если надо исполнить один и тот же код в двух местах функции, а в отдельный объект/функцию вынести трудоёмко; переносят текст функции ближе к тому месту, где он требуется; позволяют писать в функциональном стиле. Названы так в честь лямбда-исчисления, одной из основ функционального программирования.
Явный перехват объекта в лямбда-функции [=, this](){}
и [=, *this](){}
[22]. Как сказано выше, неявный перехват Шаблон:Cpp в лямбда-функциях запретили.
Традиционный синтаксис лямбда-шаблонов вместо Си++14 Шаблон:Cpp. Этот синтаксис удобнее, если нужно сделать самопроверку, или вычислить какой-нибудь производный тип[23].
// Было
auto f = [](auto vector) {
using T = typename decltype(vector)::value_type;
...
};
// Стало
auto f = []<typename T>(std::vector<T> vector) {
...
};
Лямбда-функции в невычисляемых контекстах: сигнатурах, возвращаемых типах, параметрах шаблонов[24][25].
std::priority_queue<
int, // тип элемента
std::vector<int>, // тип контейнера
decltype( [](int a, int b)->bool{ // тип функции сравнения элементов
return a>b;
})> q;
Чтобы этот код работал, нужно ещё одно изменение — лямбда-функция без перехватов теперь имеет конструктор по умолчанию и операцию присваивания[24][26]. Все экземпляры этого псевдокласса выполняют одно и то же, и никак нельзя заставить данную очередь с приоритетами сравнивать в другом порядке. Конструкторы копирования и перемещения были изначально у всех лямбда-функций.
В списке перехвата лямбда-функции теперь можно держать операцию развёртывания вариативной части[24][27] — раньше для этого приходилось подключать объект-кортеж. Например, данный шаблон возвращает лямбда-функцию, которую при желании можно вызвать когда угодно — она вызывает функцию foo() и уже содержит копии всех нужных для вызова данных.
// Было
template <class... Args>
auto delay_invoke_foo(Args... args) {
return [tup=std::make_tuple(std::move(args)...)]() -> decltype(auto) {
return std::apply([](auto const&... args) -> decltype(auto) {
return foo(args...);
}, tup);
};
}
// Стало
template <class... Args>
auto delay_invoke_foo(Args... args) {
return [args=std::move(args)...]() -> decltype(auto) {
return foo(args...);
};
}
Редакционные правки
Новые условия неявного перемещения
Уточнены условия, когда требуется неявно перемещать объект, особенно при выбросе исключений:[28]
void f() {
T x;
try {
T y;
try {g(x);}
catch(...) {
if(/*...*/)
throw x; // не переместит — x снаружи try-блока
throw y; // переместит — y внутри try-блока
}
g(y);
} catch(...) {
g(x);
// g(y); // ошибка
}
}
Числа со знаком — дополнительный код
Когда язык Си только зарождался, существовал «зоопарк» разных машин, и учебная машина MIX, придуманная Дональдом Кнутом, отражала это — байт мог хранить от 64 до 100 разных значений, а формат знаковых чисел не оговаривался. За сорок с лишним лет остановились на 8-битном байте и дополнительном коде, в первую очередь из-за простоты и интероперабельности, и это отметили в стандарте[29].
Арифметическое переполнение в беззнаковой арифметике эквивалентно операциям по модулю, в знаковой — неопределённое поведение.
Новая модель памяти
Устно нерекомендуемый с Си++17 Шаблон:Cpp, предназначенный для PowerPC и ARM, формализован и возвращается в обиход. Усилен Шаблон:Cpp[30].
Библиотека
Мелкие изменения
- Новые версии Шаблон:Cpp, связанные с массивами[31][32].
- Шаблон:Cpp и Шаблон:Cpp.
- Шаблон:Cpp, объект, позволяющий сделать атомарным что угодно[33].
- Шаблон:Cpp, Шаблон:Cpp, упрощают метапрограммирование[34].
- Шаблон:Cpp[35].
- Новый заголовок Шаблон:Cpp — стандартное место для объявлений, связанных с развитием конкретной стандартной библиотеки[36]. Объявления определяются реализацией.
- Шаблон:Cpp — преобразование указателеподобного объекта в указатель[37]. Шаблон:Cpp уже есть, но он требует разыменования, что может стать неопределённым поведением.
- Новые Шаблон:Cpp для проверки функциональности компилятора и библиотеки[38]. Стандарты Си++ огромны, и не все разработчики компиляторов быстро вносят их в свои продукты. А некоторые — сбор мусора Си++11 — остаются заглушками и поныне (2021), не реализованные ни в одном компиляторе.
- Упрощённый карринг через Шаблон:Cpp[39].
- Шаблон:Cpp — обёртка макросов Шаблон:Cpp и подобных на Си++.
- Новый заголовок Шаблон:Cpp с математическими константами[40]. До этого даже обычные π и e существовали только как расширения.
Объявление функций constexpr
- Шаблон:Cpp[41].
- Шаблон:Cpp и некоторые другие. Запись Шаблон:Cpp вместо Шаблон:Cpp стала стандартной ошибкой Си++[42][43], и она объявлена Шаблон:Cpp.
- Шаблон:Cpp[44].
- конструкторы-деструкторы std::vector и std::string, следствие послаблений в constexpr. На момент проверки (май 2020) ни один компилятор этого не поддерживает[45].
Библиотека форматирования
printf слишком низкоуровневый, опасный и нерасширяемый. Стандартные возможности Си++ позволяют только склеивать строки и потому неудобны для локализации.
Потому в Си++20 сделали более типобезопасный механизм форматирования строк, основанный на Python[46].
char c = 120;
auto s1 = std::format("{:+06d}", c); // "+00120"
auto s2 = std::format("{:#06x}", 0xa); // "0x000a"
auto s3 = std::format("{:<06}", -42); // "-42 " (0 игнорируется из-за выравнивания <)
Возможности:
- Один и тот же параметр можно форматировать сколько угодно раз разными способами.
- Подстановки можно переставлять местами.
- Выравнивание слева, по центру и справа, любым символом.
- По умолчанию числа, даты и прочее форматируются локале-нейтрально; если нужна локализация — это задаётся явно.
- Работает через шаблоны и потому расширяется на любые типы.
- Скобки можно заэкранировать
{{ }}
.
Невладеющие указатели на массив (span)
std::string_view оказался отличным объектом, и сделали аналогичное для массивов — std::span[47]. При этом span может изменять содержимое памяти, в отличие от string_view.
void do_something(std::span<int> p) {
std2::sort(p);
for (int& v: p) {
v += p[0];
}
}
// ...
std::vector<int> v;
do_something(v);
int data[1024];
do_something(data);
boost::container::small_vector<int, 32> sm;
do_something(sm);
Библиотека работы с битами <bit>
- Подсчёт количества битов
- Округление до степени двойки
- Преобразование «бит в бит» из одного типа в другой (см. Быстрый обратный квадратный корень)
- Циклический сдвиг, стандартная функция многих процессоров
- Определение порядка байтов целевой машины
Библиотека работы с синхронизированными «потоками вывода» <syncstream>
Поток вывода, как правило, своими силами отрабатывает доступ из разных потоков исполнения. При многопоточном протоколировании возникает задача: собрать данные (например, строку текста) в буфер достаточной длины и одной операцией вывести их в поток.
Для этого используется несложный класс, являющийся потомком Шаблон:Cpp.
osyncstream{cout} << "The answer is " << 6*7 << endl;
Весь вывод в подчинённый поток происходит одной операцией в деструкторе.
Библиотека диапазонов <ranges>
Сложная библиотека используется там, где нужно единообразно получить доступ, например, к std::vector и std::deque[48].
Библиотека календарей и часовых поясов в <chrono>
Сложная библиотека для календарных расчётов[49].
auto d1 = 2018_y / mar / 27;
auto d2 = 27_d / mar / 2018;
auto d3 = mar / 27 / 2018;
year_month_day today = floor<days>(system_clock::now());
assert(d1 == d2);
assert(d2 == d3);
assert(d3 == today);
Расширенная библиотека потоков <jthread>, <stop_token>
Буква j означает join — то есть при уничтожении объекта-потока система дожидается окончания задачи.
Кроме того, с помощью библиотеки Шаблон:Cpp можно попросить поток остановиться.
#include <thread>
#include <iostream>
using namespace std::literals::chrono_literals;
void f(std::stop_token stop_token, int value)
{
while (!stop_token.stop_requested()) {
std::cout << value++ << ' ' << std::flush;
std::this_thread::sleep_for(200ms);
}
std::cout << std::endl;
}
int main()
{
std::jthread thread(f, 5); // prints 5 6 7 8... for approximately 3 seconds
std::this_thread::sleep_for(3s);
// The destructor of jthread calls request_stop() and join().
}
Барьеры и засовы
Барьер (barrier) — механизм межпоточной синхронизации, действующий так: как только у барьера соберутся n потоков, он исполнит объект-функцию и отпустит их. Обычно используется для периодической координации частично распараллеливаемых задач: после того, как потоки исполнят каждый свою долю, срабатывает координатор и решает, что делать дальше.
Засов (latch) — упрощённый одноразовый барьер[50].
Разнородный поиск в unordered_set/map
Основное назначение: ключи хранения — «тяжёлые» объекты (например, string), но в качестве ключа поиска допустимы и облегчённые: string_view и даже const char*. Реализовано оно крайне просто: добавлена шаблонная функция find, принимающая любой тип, сам же разнородный поиск включается типом-маркером Шаблон:Cpp[51]. Поддерживаются четыре функции: find, count, equal_range, contains. В Си++23 ожидается больше функций, поддерживающих разнородный поиск — например, erase[52].
Для самобалансирующихся деревьев поиска (set/map) реализовано в Си++14.
Эта функция не включена по умолчанию из-за ошибкоопасности: преобразование типов может не сохранять те соотношения, на которых работает контейнер. Например, Шаблон:Cpp, но Шаблон:Cpp. Потому поиск дробного числа в Шаблон:Cpp приведёт не к тому, что надо[53]. Так что программист сам должен допустить те альтернативные ключи, которые заведомо годятся.
struct string_hash {
using is_transparent = void;
[[nodiscard]] size_t operator()(const char *txt) const {
return std::hash<std::string_view>{}(txt);
}
[[nodiscard]] size_t operator()(std::string_view txt) const {
return std::hash<std::string_view>{}(txt);
}
[[nodiscard]] size_t operator()(const std::string &txt) const {
return std::hash<std::string>{}(txt);
}
};
std::unordered_map<std::string, int, string_hash, std::equal_to<>> m {
{ "Hello Super Long String", 1 },
{ "Another Longish String", 2 },
{"This cannot fall into SSO buffer", 3 }
};
bool found = m.contains("Hello Super Long String");
std::cout << "Found: " << std::boolalpha << found << '\n';
Реализованы как экспериментальные библиотеки
- Параллелизм v2[54], в том числе task blocks. Версия 1 внесена в Си++17.
- Рефлексия v1[55]
- Сеть v1[56]
Оставлены на будущее
- Контракты — есть конкурирующее предложение
- Метаклассы
- Исполнители
- Свойства
- Расширенные future
См. также
Примечания
Шаблон:Язык программирования C++
развернутьПартнерские ресурсы |
---|
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Перейти обратно: 24,0 24,1 24,2 Шаблон:Cite news
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web
- ↑ Шаблон:Cite web