C ++ 11

C ++ 11 - это версия стандарта для языка программирования С ++. Он был одобрен Международной организацией по стандартизации (ISO) 12 августа 2011 года, заменив C ++ 03, замененный на C ++ 14 18 августа 2014 года. и позже на C ++ 17. Название следует традиции именования языковых версий по году публикации спецификации, хотя ранее оно называлось C ++ 0x, поскольку ожидалось, что оно будет опубликовано до 2010 года.

Хотя одной из целей дизайна было предпочитаете изменения в библиотеках изменениям в базовом языке, C ++ 11 действительно вносит несколько дополнений в базовый язык. Области основного языка, которые были значительно улучшены, включают поддержку многопоточности, поддержку общего программирования,, унифицированную инициализацию и производительность. Существенные изменения были также внесены в стандартную библиотеку C ++, включающую большинство библиотек Технического отчета 1 (TR1) , за исключением библиотеки специальных математических функций.

C ++ 11 был опубликован как ISO / IEC 14882: 2011 в сентябре 2011 года и доступен за плату. Рабочий проект, наиболее похожий на опубликованный стандарт C ++ 11, - это N3337 от 16 января 2012 г.; в него внесены только редакционные исправления из стандарта C ++ 11.

• 1 Цели разработки
• 2 Расширения основного языка C ++
  • 2.1 Повышение производительности среды выполнения основного языка
    • 2.1.1 Ссылки на Rvalue и конструкторы перемещения
    • 2.1.2 constexpr - Обобщенные константные выражения
    • 2.1.3 Модификация определения простых старых данных
  • 2.2 Повышение производительности во время сборки основного языка
    • 2.2.1 Внешний шаблон
  • 2.3 Улучшения удобства использования основного языка
    • 2.3.1 Списки инициализаторов
    • 2.3.2 Унифицированная инициализация
    • 2.3.3 Выведение типа
    • 2.3.4 На основе диапазона для цикла
    • 2.3.5 Лямбда-функции и выражения
    • 2.3.6 Альтернативный синтаксис функции
    • 2.3.7 Улучшение конструкции объекта
    • 2.3.8 Явное переопределение и окончательное
    • 2.3.9 Константа нулевого указателя
    • 2.3.10 Строго типизированные перечисления
    • 2.3.11 Правая угловая скобка
    • 2.3.12 Операторы явного преобразования
    • 2.3.13 Псевдонимы шаблонов
    • 2.3.14 Неограниченные объединения
  • 2.4 Основные возможности языка im Доказательства
    • 2.4.1 Вариативные шаблоны
    • 2.4.2 Новые строковые литералы
    • 2.4.3 Пользовательские литералы
    • 2.4.4 Модель многопоточной памяти
    • 2.4.5 Локальное хранилище потока
    • 2.4.6 Явно установленные по умолчанию и удаленные специальные функции-члены
    • 2.4.7 Тип long long int
    • 2.4.8 Статические утверждения
    • 2.4.9 Разрешить sizeof работать с членами классов без явного объекта
    • 2.4.10 Выравнивание объектов управления и запроса
    • <3>2.4.11 Разрешить реализации со сборкой мусора
    • 2.4.12 Атрибуты
• 3 Изменения в стандартной библиотеке C ++
  • 3.1 Обновление компонентов стандартной библиотеки
  • 3.2 Возможности потоковой передачи
  • 3.3 Типы кортежей
  • 3.4 Хеш-таблицы
  • 3.5 Регулярные выражения
  • 3.6 Универсальные интеллектуальные указатели
  • 3.7 Расширяемое средство случайных чисел
  • 3.8 Ссылка на оболочку
  • 3.9 Полиморфные оболочки для функциональных объектов
  • 3.10 Типовые характеристики для метапрограммирования
  • 3.11 Единый метод для вычисления типа возвращаемого значения функциональных объектов
• 4 Улучшенная совместимость с C
• 5 Особенности оригинала Планируется, но удалено или не включено
• 6 Функции удалены или признаны устаревшими
• 7 См. также
• 8 Ссылки
• 9 Внешние ссылки

Комитет по дизайну попытался придерживаться ряд целей при разработке C ++ 11:

• Поддержание стабильности и совместимости с C ++ 98 и, возможно, с C
• Предпочитать вводить новые функции через стандартную библиотеку, а не расширять базовый язык
• Предпочитайте изменения, которые могут развить технику программирования
• Улучшайте C ++ для облегчения проектирования систем и библиотек, а не вводите новые функции, полезные только для определенных приложений
• Повышайте безопасность типов, обеспечивая более безопасные альтернативы более ранним небезопасным методам
• Повышение производительности и возможность работы напрямую с оборудованием
• Обеспечение надлежащих решений реальных проблем
• Реализация принципа нулевых накладных расходов (требуется дополнительная поддержка некоторыми утилитами должен использоваться только в том случае, если используется утилита)
• Сделайте C ++ легким для обучения и изучения n без удаления каких-либо утилит, необходимых опытным программистам

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

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

Повышение производительности среды выполнения основного языка

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

Ссылки Rvalue и конструкторы перемещения

В C ++ 03 (и ранее) временные объекты (называемые «rvalues ​​ », поскольку они часто лежат справа от присваивания) никогда не предназначались для изменения - так же, как в C - и считались неотличимыми от типов const T; тем не менее, в некоторых случаях временные конструкции могли быть изменены, что даже считалось полезной лазейкой. В C ++ 11 добавлен новый неконстантный ссылочный тип, называемый ссылкой rvalue, который обозначается T. Это относится к временным файлам, которые разрешено изменять после их инициализации с целью обеспечения «семантики перемещения».

Хроническая проблема производительности C ++ 03 - это дорогостоящие и ненужные глубокие копии, которые могут происходить неявно, когда объекты передаются по значению. Чтобы проиллюстрировать проблему, представьте, что std::vectorвнутри является оболочкой для массива в стиле C с определенным размером. Если временный std::vectorсоздается или возвращается из функции, его можно сохранить, только создав новый std::vectorи скопировав все rvalue в него. Тогда временное и вся его память уничтожаются. (Для простоты в этом обсуждении не рассматривается оптимизация возвращаемого значения .)

В C ++ 11 конструктор перемещения из std :: vector , который принимает ссылку rvalue на std::vector, может скопировать указатель на внутренний массив в стиле C из rvalue в новый std :: vector , затем установите указатель внутри rvalue на ноль. Поскольку временное значение больше никогда не будет использоваться, никакой код не будет пытаться получить доступ к нулевому указателю, а поскольку указатель является нулевым, его память не удаляется, когда он выходит за пределы области видимости. Следовательно, операция не только не требует затрат на глубокое копирование, но и безопасна и невидима.

Ссылки Rvalue могут обеспечить повышение производительности существующего кода без необходимости вносить какие-либо изменения за пределами стандартной библиотеки. Тип возвращаемого значения функции, возвращающей временный std::vector, не нужно явно изменять на std :: vector для вызова move конструктор, так как временные значения автоматически считаются r-значениями. (Однако, если std::vectorявляется версией C ++ 03 без конструктора перемещения, то конструктор копирования будет вызываться с const std :: vector , что приводит к значительному выделению памяти.)

Из соображений безопасности наложены некоторые ограничения. Именованная переменная никогда не будет считаться rvalue, даже если она объявлена ​​как таковая. Чтобы получить rvalue, следует использовать шаблон функции std :: move (). Ссылки Rvalue также могут быть изменены только при определенных обстоятельствах, они предназначены для использования в основном с конструкторами перемещения.

Из-за характера формулировки ссылок rvalue и некоторых изменений формулировки ссылок lvalue (регулярные ссылки) ссылки rvalue позволяют разработчикам обеспечивать идеальную пересылку функций. В сочетании с вариативными шаблонами эта возможность позволяет использовать шаблоны функций, которые могут идеально передавать аргументы другой функции, которая принимает эти конкретные аргументы. Это наиболее полезно для пересылки параметров конструктора, чтобы создать фабричные функции, которые будут автоматически вызывать правильный конструктор для этих конкретных аргументов. Это видно в наборе emplace_back методов стандартной библиотеки C ++.

constexpr - Обобщенные константные выражения

В C ++ всегда была концепция константных выражений. Это такие выражения, как 3 + 4, которые всегда будут давать одни и те же результаты во время компиляции и во время выполнения. Постоянные выражения - это возможности оптимизации для компиляторов, и компиляторы часто выполняют их во время компиляции и жестко кодируют результаты в программе. Кроме того, в некоторых местах спецификация C ++ требует использования постоянных выражений. Для определения массива требуется постоянное выражение, а значения перечислителя должны быть постоянными выражениями.

Однако постоянное выражение никогда не могло содержать вызов функции или конструктор объекта. Поэтому такой простой фрагмент кода недействителен:

int get_five () {return 5;} int some_value [get_five () + 7]; // Создаем массив из 12 целых чисел. Неправильно сформированный C ++

Это недопустимо в C ++ 03, потому что get_five () + 7не является постоянным выражением. Компилятор C ++ 03 не может узнать, является ли get_five ()на самом деле постоянным во время выполнения. Теоретически эта функция может влиять на глобальную переменную, вызывать другие функции констант времени выполнения и т. Д.

В C ++ 11 введено ключевое слово constexpr, которое позволяет пользователю гарантировать, что Конструктор функции или объекта - это константа времени компиляции. Приведенный выше пример можно переписать следующим образом:

constexpr int get_five () {return 5;} int some_value [get_five () + 7]; // Создаем массив из 12 целых чисел. Допустимый C ++ 11

Это позволяет компилятору понять и проверить, что get_five ()является константой времени компиляции.

Использование constexprдля функции накладывает некоторые ограничения на то, что эта функция может делать. Во-первых, функция должна иметь непустой возвращаемый тип. Во-вторых, тело функции не может объявлять переменные или определять новые типы. В-третьих, тело может содержать только объявления, пустые операторы и один оператор возврата. Должны существовать такие значения аргументов, чтобы после подстановки аргументов выражение в операторе return давало постоянное выражение.

До C ++ 11 значения переменных можно было использовать в постоянных выражениях, только если переменные объявлены как константы, имеют инициализатор, который является константным выражением, и имеют целочисленный или перечисляемый тип. C ++ 11 снимает ограничение на то, что переменные должны быть целочисленного или перечислительного типа, если они определены с помощью ключевого слова constexpr:

constexpr double earth_gravitational_acceleration = 9.8; constexpr двойной moon_gravitational_acceleration = earth_gravitational_acceleration / 6.0;

Такие переменные данных неявно являются константами и должны иметь инициализатор, который должен быть константным выражением.

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

Конструктор копирования для типа с любыми конструкторами constexprобычно также должен быть определен как конструктор constexpr, чтобы позволить объектам типа возвращаться по значению из функция constexpr. Любая функция-член класса, такая как конструкторы копирования, перегрузки операторов и т. Д., Может быть объявлена ​​как constexpr, если они соответствуют требованиям для функций constexpr. Это позволяет компилятору копировать объекты во время компиляции, выполнять над ними операции и т. Д.

Если функция или конструктор constexpr вызывается с аргументами, которые не являются постоянными выражениями, вызов ведет себя так, как если бы функция не была constexpr, и полученное значение не является постоянным выражением. Аналогичным образом, если выражение в операторе return функции constexpr не оценивается как постоянное выражение для данного вызова, результат не является постоянным выражением.

constexprотличается от consteval, представленного в C ++ 20, тем, что последний всегда должен создавать константу времени компиляции, а constexprне имеет этого ограничения.

Изменение определения простых старых данных

В C ++ 03 класс или структура должны следовать ряду правил, чтобы считаться простыми старыми данными Тип (POD). Типы, соответствующие этому определению, создают макеты объектов, совместимые с C, и их также можно инициализировать статически. Стандарт C ++ 03 имеет ограничения на то, какие типы совместимы с C или могут быть статически инициализированы, несмотря на отсутствие технических причин, по которым компилятор не мог принять программу; если кто-то создаст тип POD C ++ 03 и добавит невиртуальную функцию-член, этот тип больше не будет типом POD, его нельзя будет статически инициализировать и он будет несовместим с C, несмотря на отсутствие изменений в макете памяти..

C ++ 11 ослабил некоторые правила POD, разделив концепцию POD на две отдельные концепции: тривиальную и стандартную компоновку.

Тривиальный тип можно статически инициализировать. Это также означает, что допустимо копировать данные через memcpy, вместо того, чтобы использовать конструктор копирования. Время жизни тривиального типа начинается с момента определения его хранилища, а не с момента завершения конструктора.

Тривиальный класс или структура определяется как класс, который:

1. Имеет тривиальный конструктор по умолчанию. При этом может использоваться синтаксис конструктора по умолчанию (SomeConstructor () = default;).
2. Имеет тривиальные конструкторы копирования и перемещения, которые могут использовать синтаксис по умолчанию.
3. Имеет тривиальную копию и перемещать операторы присваивания, которые могут использовать синтаксис по умолчанию.
4. Имеет тривиальный деструктор, который не должен быть виртуальным.

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

Тип со стандартной компоновкой означает, что он упорядочивает и упаковывает свои элементы способом, совместимым с C. struct является стандартным макетом, по определению, при условии:

1. У него нет виртуальных функций
2. У него нет виртуальных базовых классов
3. Все его нестатические элементы данных имеют одинаковый контроль доступа ( public, private, protected)
4. Все его нестатические элементы данных, включая любые его базовые классы, находятся в одном и том же классе в иерархии
5. Вышеупомянутые правила также применяется ко всем базовым классам и ко всем нестатическим элементам данных в иерархии классов
6. Он не имеет базовых классов того же типа, что и первый определенный нестатический член данных

Класс / структура / union считается POD, если он является тривиальным, стандартным макетом, и все его нестатические элементы данных и базовые классы являются POD.

Разделив эти концепции, можно отказаться от одного, не потеряв другого. Класс со сложными конструкторами перемещения и копирования может быть нетривиальным, но он может иметь стандартный макет и, таким образом, взаимодействовать с C. Точно так же класс с общедоступными и частными нестатическими элементами данных не будет стандартным макетом, но он может быть тривиально и, следовательно, memcpy-able.

Повышение производительности во время сборки основного языка

Шаблон Extern

В C ++ 03 компилятор должен создавать экземпляр шаблона всякий раз, когда полностью указанный шаблон встречается в единице перевода. Если шаблон создается с одними и теми же типами во многих единицах перевода, это может значительно увеличить время компиляции. В C ++ 03 нет способа предотвратить это, поэтому C ++ 11 представил объявления шаблона extern, аналогичные объявлениям extern данных.

C ++ 03 имеет следующий синтаксис, чтобы заставить компилятор создать экземпляр шаблона:

шаблонный класс std :: vector ;

C ++ 11 теперь предоставляет следующий синтаксис:

extern template class std :: vector ;

, который сообщает компилятору не создавать экземпляр шаблона в этой единице перевода.

Повышение удобства использования основного языка

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

Списки инициализаторов

C ++ 03 унаследовал функцию списка инициализаторов от C. Структура или массив дан список аргументов в фигурных скобках в порядке определений членов в структуре. Эти списки инициализаторов рекурсивны, поэтому их может использовать массив структур или структура, содержащая другие структуры.

struct Object {сначала float; int second; }; Скаляр объекта = {0.43f, 10}; // Один объект, где first = 0.43f и second = 10 Object anArray = {{13.4f, 3}, {43.28f, 29}, {5.934f, 17}}; // Массив из трех объектов

Это очень полезно для статических списков или инициализации структуры некоторым значением. C ++ также предоставляет конструкторы для инициализации объекта, но они часто не так удобны, как список инициализаторов. Однако C ++ 03 разрешает списки инициализаторов только для структур и классов, которые соответствуют определению Plain Old Data (POD); C ++ 11 расширяет списки инициализаторов, поэтому их можно использовать для всех классов, включая стандартные контейнеры, такие как std :: vector.

. C ++ 11 связывает концепцию с шаблоном, называемым std :: initializer_list. Это позволяет конструкторам и другим функциям принимать списки инициализаторов в качестве параметров. Например:

класс SequenceClass {public: SequenceClass (std :: initializer_list список); };

Это позволяет создать SequenceClassиз последовательности целых чисел, например:

SequenceClass some_var = {1, 4, 5, 6};

Этот конструктор представляет собой особый тип конструктора, называемый конструктором списка инициализаторов. Классы с таким конструктором обрабатываются специально во время унифицированной инициализации (см. ниже)

Класс шаблона std::initializer_list<>- это первоклассный C ++ 11 стандартный библиотечный тип. Они могут быть сконструированы компилятором C ++ 11 статически с помощью синтаксиса {}без имени типа в контекстах, где такие фигурные скобки будут выводить std :: initializer_list, или явно указав тип, например std :: initializer_list {args}(и так далее для других вариантов синтаксиса конструкции).

Список можно скопировать после создания, что дешево и будет действовать как копирование по ссылке (класс обычно реализуется как пара указателей начала / конца). std :: initializer_listявляется постоянным: его члены не могут быть изменится после его создания, и данные в этих членах не могут быть изменены (что исключает перемещение от них, требует копирования в члены класса и т. д.).

Хотя его конструкция специально обрабатывается com piler std :: initializer_listявляется реальным типом, поэтому его можно использовать в других местах, помимо конструкторов классов. Обычные функции могут принимать в качестве аргументов типизированные std :: initializer_list. Например:

void имя_функции (std :: initializer_list список); // Копирование дешево; см. выше имя_функции ({1.0f, -3.45f, -0.4f});

Примеры этого в стандартной библиотеке включают шаблоны std :: min ()и std :: max (), принимающие std :: initializer_lists числового типа.

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

std :: vector v = {"xyzzy", "plugh", "abracadabra"}; std :: vector v ({"xyzzy", "plugh", "abracadabra"}); std :: vector v {"xyzzy", "plugh", "abracadabra"}; // см. «Единая инициализация» ниже

Единая инициализация

C ++ 03 имеет ряд проблем с инициализацией типов. Существует несколько способов сделать это, и некоторые из них при замене дают разные результаты. Например, традиционный синтаксис конструктора может выглядеть как объявление функции, и необходимо предпринять шаги, чтобы гарантировать, что правило самого неприятного синтаксического анализа компилятора не ошибочно принимает его за такое. Только агрегаты и типы POD могут быть инициализированы агрегатными инициализаторами (используя SomeType var = {/ * stuff * /};).

C ++ 11 предоставляет синтаксис, который позволяет полностью унифицировать инициализацию типа, которая работает с любым объектом. Он расширяет синтаксис списка инициализаторов:

struct BasicStruct {int x; двойной y; }; struct AltStruct {AltStruct (int x, double y): x_ {x}, y_ {y} {} private: int x_; двойной y_; }; BasicStruct var1 {5, 3.2}; AltStruct var2 {2, 4.3};

Инициализация var1ведет себя точно так же, как если бы это была агрегированная инициализация. То есть каждый элемент данных объекта, в свою очередь, будет инициализирован копией с соответствующим значением из списка инициализаторов. При необходимости будет использоваться неявное преобразование типа. Если преобразование отсутствует или существует только сужающее преобразование, программа сформирована неправильно. Инициализация var2вызывает конструктор.

Также можно сделать это:

struct IdString {std :: string name; int идентификатор; }; IdString get_string () {return {"foo", 42}; // Обратите внимание на отсутствие явного типа. }

Единая инициализация не заменяет синтаксис конструктора, который иногда все же необходим. Если у класса есть конструктор списка инициализаторов (TypeName (initializer_list );), то он имеет приоритет над другими формами построения, при условии, что список инициализаторов соответствует типу конструктора последовательности. Версия C ++ 11 для std :: vectorимеет конструктор списка инициализаторов для своего типа шаблона. Таким образом, этот код:

std :: vector the_vec {4};

вызовет конструктор списка инициализаторов, а не конструктор std :: vector, который принимает один параметр размера и создает вектор с этим размером. Чтобы получить доступ к последнему конструктору, пользователю необходимо напрямую использовать стандартный синтаксис конструктора.

Определение типа

В C ++ 03 (и C) для использования переменной ее тип должен быть указан явно. Однако с появлением типов шаблонов и методов метапрограммирования шаблонов тип чего-либо, особенно четко определенного возвращаемого значения функции, может быть нелегко выразить. Таким образом, хранение промежуточных продуктов в переменных затруднено, возможно, для этого потребуется знание внутреннего устройства данной библиотеки метапрограммирования.

C ++ 11 позволяет смягчить это двумя способами. Во-первых, определение переменной с явной инициализацией может использовать ключевое слово auto. Это создает переменную определенного типа инициализатора:

auto some_strange_callable_type = std :: bind (some_function, _2, _1, some_object); auto other_variable = 5;

Тип some_strange_callable_type- это просто то, что конкретное переопределение функции шаблона std :: bindвозвращает для этих конкретных аргументов. Этот тип легко определяется компилятором процедурно в рамках его обязанностей по семантическому анализу, но пользователю нелегко определить его при проверке. Тип other_variableтакже четко определен, но его легче определить пользователю. Это int, который имеет тот же тип, что и целочисленный литерал.

Это использование ключевого слова autoв C ++ изменяет назначение семантики этого ключевого слова, которое изначально использовалось в безтиповом языке-предшественнике B в связанной роли обозначающий нетипизированное автоматическое определение переменной.

Кроме того, ключевое слово decltype может использоваться для определения типа выражения во время компиляции. Например:

int some_int; decltype (some_int) other_integer_variable = 5;

Это более полезно в сочетании с auto, поскольку тип переменной auto известен только компилятору. Однако decltypeтакже может быть очень полезен для выражений в коде, которые интенсивно используют перегрузку оператора и специализированные типы.

autoтакже полезно для уменьшения многословности кода. Например, вместо записи

для (std :: vector :: const_iterator itr = myvec.cbegin (); itr! = Myvec.cend (); ++ itr)

программист может использовать короче

для (auto itr = myvec.cbegin (); itr! = myvec.cend (); ++ itr)

, который может быть дополнительно уплотнен, поскольку "myvec" реализует итераторы начала / конца:

для (auto x: myvec)

Эта разница увеличивается, когда программист начинает вкладывать контейнеры, хотя в таких случаях typedefявляются хорошим способом уменьшить объем кода.

Тип, обозначенный decltype, может отличаться от типа, выведенного с помощью auto.

#include int main () {const std :: vector v (1); авто а = v [0]; // a имеет тип int decltype (v [0]) b = 1; // b имеет тип const int, тип возвращаемого значения // std :: vector :: operator (size_type) const auto c = 0; // c имеет тип int auto d = c; // d имеет тип int decltype (c) e; // e имеет тип int, тип сущности, названной c decltype ((c)) f = c; // f имеет тип int, потому что (c) - это lvalue decltype (0) g; // g имеет тип int, потому что 0 - это rvalue}

Цикл for на основе диапазона

C ++ 11 расширяет синтаксис оператора for, чтобы упростить итерацию по диапазон элементов:

int my_array [5] = {1, 2, 3, 4, 5}; // удвоить значение каждого элемента в my_array: for (int x: my_array) x * = 2; // аналогично, но также с использованием вывода типа для элементов массива for (auto x: my_array) x * = 2;

Эта форма для, называемая «на основе диапазона для», будет перебирать каждый элемент в списке. Он будет работать для массивов в стиле C, списков инициализаторов и любого типа, для которого определены функции begin ()и end (), возвращающие итераторы. Все стандартные библиотечные контейнеры с парами начало / конец будут работать с оператором for на основе диапазона.

Лямбда-функции и выражения

C ++ 11 предоставляет возможность создавать анонимные функции, называемые лямбда-функциями. Они определены следующим образом:

(int x, int y) ->int {return x + y; }

Тип возврата (->intв этом примере) можно не указывать, если все выражения returnвозвращают один и тот же тип. Лямбда необязательно может быть замыканием.

Альтернативный синтаксис функции

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

template Ret add_func (const Lhs lhs, const Rhs rhs) {return lhs + rhs;} // Ret должен иметь тип lhs + rhs

Тип Ret- это то, что приведет к сложению типов Lhsи Rhs. Даже с вышеупомянутой функциональностью C ++ 11 decltypeэто невозможно:

template decltype (lhs + rhs) added_func (const Lhs lhs, const Rhs rhs) {return lhs + rhs;} // Недействительный C ++ 11

Это недопустимый C ++, потому что lhsи rhsеще не определены; они не будут действительными идентификаторами до тех пор, пока синтаксический анализатор не проанализирует остальную часть прототипа функции.

Чтобы обойти это, C ++ 11 представил новый синтаксис объявления функции с конечным возвращаемым типом:

шаблон auto add_func (const Lhs lhs, const Rhs rhs) ->decltype (lhs + rhs) {return lhs + rhs;}

Этот синтаксис можно использовать для более простых объявлений и определений функций:

struct SomeStruct {auto func_name (int x, int y) ->int; }; авто SomeStruct :: func_name (int x, int y) ->int {return x + y; }

Использование ключевого слова «auto» в этом случае является только частью синтаксиса и не выполняет автоматического определения типа.

Улучшение конструкции объекта

В C ++ 03 конструкторы класса не разрешено вызывать другие конструкторы в списке инициализаторов этого класса. Каждый конструктор должен сам создать все свои члены класса или вызвать общую функцию-член, как показано ниже:

class SomeType {public: SomeType (int new_number) {Construct (new_number); } SomeType () {Construct (42); } частный: void Construct (int new_number) {number = new_number; } int число; };

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

C ++ 11 предоставляет решения всех этих проблем.

C ++ 11 позволяет конструкторам вызывать другие одноранговые конструкторы (так называемое делегирование ). Это позволяет конструкторам использовать поведение другого конструктора с минимумом добавленного кода. Делегирование использовалось в других языках, например, Java и Objective-C.

Этот синтаксис выглядит следующим образом:

class SomeType {int number; public: SomeType (int new_number): number (new_number) {} SomeType (): SomeType (42) {}};

Обратите внимание, что в этом случае того же эффекта можно было бы добиться, сделав new_numberпараметром по умолчанию. Новый синтаксис, однако, позволяет выражать значение по умолчанию (42) в реализации, а не в интерфейсе - преимущество для разработчиков библиотечного кода, поскольку значения по умолчанию для параметров функции «запекаются» для вызова сайтов, тогда как делегирование конструктора позволяет значение, которое нужно изменить без перекомпиляции кода с помощью библиотеки.

Здесь есть предостережение: C ++ 03 считает, что объект создается, когда его конструктор завершает выполнение, но C ++ 11 считает, что объект создан после завершения выполнения любого конструктора. Поскольку будет разрешено выполнение нескольких конструкторов, это будет означать, что каждый делегирующий конструктор будет выполняться на полностью построенном объекте своего собственного типа. Конструкторы производных классов будут выполняться после завершения всего делегирования в их базовых классах.

Для конструкторов базового класса C ++ 11 позволяет классу указывать, что конструкторы базового класса будут унаследованы. Таким образом, компилятор C ++ 11 сгенерирует код для выполнения наследования и перенаправления производного класса базовому классу. Это функция «все или ничего»: либо все конструкторы этого базового класса перенаправляются, либо ни один из них не перенаправляется. Also, an inherited constructor will be shadowed if it matches the signature of a constructor of the derived class, and restrictions exist for multiple inheritance: class constructors cannot be inherited from two classes that use constructors with the same signature.

The syntax is as follows:

class BaseClass { public: BaseClass(int value); }; class DerivedClass : public BaseClass { public: using BaseClass::BaseClass; };

For member initialization, C++11 allows this syntax:

class SomeClass { public: SomeClass() {} explicit SomeClass(int new_value) : value(new_value) {} private: int value = 5; };

Any constructor of the class will initialize valuewith 5, if the constructor does not override the initialization with its own. So the above empty constructor will initialize valueas the class definition states, but the constructor that takes an int will initialize it to the given parameter.

It can also use constructor or uniform initialization, instead of the assignment initialization shown above.

Explicit overrides and final

In C++03, it is possible to accidentally create a new virtual function, when one intended to override a base class function. For example:

struct Base { virtual void some_func(float); }; struct Derived : Base { virtual void some_func(int); };

Suppose the Derived::some_funcis intended to replace the base class version. But instead, because it has a different signature, it creates a second virtual function. This is a common problem, particularly when a user goes to modify the base class.

C++11 provides syntax to solve this problem.

struct Base { virtual void some_func(float); }; struct Derived : Base { virtual void some_func(int)переопределить; // плохо сформированный - не отменяет метод базового класса};

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

C ++ 11 также добавляет возможность предотвращения наследования от классов или просто предотвращения переопределения методов в производных классах. Это делается с помощью специального идентификатора final. Например:

struct Base1 final {}; struct Derived1: Base1 {}; // неправильно сформирован, потому что класс Base1 помечен как final

struct Base2 {virtual void f () final; }; struct Derived2: Base2 {void f (); // неправильно сформирован, потому что виртуальная функция Base2 :: f помечена как окончательная};

В этом примере оператор virtual void f () final;объявляет новую виртуальную функцию, но также предотвращает ее переопределение производными классами. Это также предотвращает использование производными классами этого конкретного имени функции и комбинации параметров.

Обратите внимание, что ни override, ни finalне являются ключевыми словами языка. С технической точки зрения они являются идентификаторами атрибутов декларатора:

• они приобретают особое значение как атрибуты только при использовании в этих конкретных конечных контекстах (после всех спецификаторов типов, спецификаторов доступа, объявлений членов (для типов структур, классов и перечислений) и спецификаторов деклараторов, но перед инициализацией или реализацией кода каждого декларатора в списке деклараторов, разделенных запятыми);
• они не изменяют сигнатуру объявленного типа и не объявляют и не переопределяют какой-либо новый идентификатор в любой области;
• распознанные и принятые атрибуты декларатора могут быть расширены в будущих версиях C ++ (некоторые специфичные для компилятора расширения уже распознают добавленные атрибуты декларатора, чтобы предоставить компилятору параметры генерации кода или подсказки по оптимизации, либо для генерации добавленных данных в скомпилированный код, как предполагалось для отладчиков, компоновщиков и развертывания скомпилированного кода, или для предоставления дополнительных системных атрибутов безопасности, или для улучшения возможностей отражения во время выполнения, или для ovide добавлена ​​информация о привязке для взаимодействия с другими языками программирования и системами времени выполнения; эти расширения могут принимать параметры в скобках после идентификатора атрибута декларатора; для соответствия ANSI эти специфичные для компилятора расширения должны использовать соглашение о двойном префиксе подчеркивания).
• В любом другом месте они могут быть действительными идентификаторами для новых объявлений (и использоваться позже, если они доступны).

Константа нулевого указателя

Для целей этого раздела и только этого раздела каждое вхождение «0» означает «постоянное выражение, которое оценивается как 0, который имеет тип int ». В действительности постоянное выражение может быть любого целочисленного типа.

С момента появления C в 1972 году константа 0 выполняла двойную роль константы целого числа и константы нулевого указателя. Неоднозначность, присущая двойному значению 0, была устранена в C с помощью макроса препроцессора NULL, который обычно расширяется до ((void *) 0)или 0. C ++ запрещает неявное преобразование из void *в другие типы указателей, тем самым устраняя преимущество преобразования 0в void *. Как следствие, только 0допускается в качестве константы нулевого указателя. Это плохо взаимодействует с перегрузкой функции :

void foo (char *); void foo (int);

Если NULLопределяется как 0(что обычно имеет место в C ++), оператор foo (NULL);вызовет foo (int), что почти наверняка не то, что задумал программист, и не то, что подсказывает поверхностное прочтение кода.

C ++ 11 исправляет это, вводя новое ключевое слово, служащее отличительной константой нулевого указателя: nullptr. Это тип nullptr_t, который неявно преобразуется и сравним с любым типом указателя или типом указателя на член. Он не может быть неявно преобразован или сопоставим с целочисленными типами, за исключением bool. Хотя в исходном предложении указывалось, что rvalue типа nullptr_tне должно быть преобразовано в bool, рабочая группа по основному языку решила, что такое преобразование было бы желательным для согласованности с обычными типами указателей.. Предложенные изменения формулировки были единогласно внесены в Рабочий документ в июне 2008 года. Аналогичное предложение также внесено в стандартную рабочую группу C.

По причинам обратной совместимости 0остается действительным нулевым константа указателя.

char * pc = nullptr; // ОК int * pi = nullptr; // ОК bool b = nullptr; // ОК. b ложно. int i = nullptr; // ошибка foo (nullptr); // вызывает foo (nullptr_t), а не foo (int); / * Обратите внимание, что foo (nullptr_t) фактически вызовет foo (char *) в приведенном выше примере с использованием неявного преобразования, только если никакие другие функции не перегружаются совместимыми типами указателей в области видимости. Если существует несколько перегрузок, разрешение не удастся, поскольку оно неоднозначно, если нет явного объявления foo (nullptr_t). В заголовках стандартных типов для C ++ 11 тип nullptr_t должен быть объявлен как: typedef decltype (nullptr) nullptr_t; но не как: typedef int nullptr_t; // предыдущие версии C ++, для которых необходимо, чтобы NULL был определен как 0 typedef void * nullptr_t; // ANSI C, который определяет NULL как ((void *) 0) * /

Строго типизированные перечисления

В C ++ 03 перечисления не являются типобезопасными. По сути, это целые числа, даже если типы перечисления различны. Это позволяет сравнивать два значения перечисления разных типов перечисления. Единственная безопасность, которую обеспечивает C ++ 03, заключается в том, что целое число или значение одного типа перечисления не преобразуется неявно в другой тип перечисления. Кроме того, базовый интегральный тип определяется реализацией; код, который зависит от размера перечисления, таким образом, непереносим. Наконец, значения перечисления ограничиваются охватывающей областью. Таким образом, два отдельных перечисления в одной области не могут иметь совпадающие имена членов.

C ++ 11 допускает специальную классификацию перечислений, не имеющую ни одной из этих проблем. Это выражается с помощью объявления enum class(enum structтакже принимается как синоним):

enum class Enumeration {Val1, Val2, Val3 = 100, Val4 // = 101};

Это перечисление типобезопасно. Значения класса Enum не конвертируются в целые числа неявно. Таким образом, их тоже нельзя сравнивать с целыми числами (выражение Enumeration :: Val4 == 101дает ошибку компиляции).

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

enum class Enum2: unsigned int {Val1, Val2};

В перечислениях старого стиля значения помещаются во внешнюю область. В перечислениях нового стиля они помещаются в область действия имени класса перечисления. Итак, в приведенном выше примере Val1не определено, но определено Enum2 :: Val1.

Существует также переходный синтаксис, позволяющий перечислениям в старом стиле предоставлять явную область видимости, и определение базового типа:

enum Enum3: unsigned long {Val1 = 1, Val2};

В этом случае имена перечислителя определены в области действия перечисления (Enum3 :: Val1), но для обратной совместимости они также помещаются во включающую область.

Перечисления с прямым объявлением также возможны в C ++ 11. Раньше типы перечисления не могли быть объявлены вперед, потому что размер перечисления зависит от определения его членов. Если размер перечисления указан неявно или явно, его можно объявить вперед:

enum Enum1; // Недействительно в C ++ 03 и C ++ 11; базовый тип не может быть определен. перечисление Enum2: целое число без знака; // Допустимо в C ++ 11, базовый тип указан явно. enum class Enum3; // Допустимо в C ++ 11, базовый тип - int. enum class Enum4: unsigned int; // Допустимо в C ++ 11. перечисление Enum2: беззнаковое короткое; // Недействительно в C ++ 11, потому что Enum2 ранее был объявлен с другим базовым типом.

Правая угловая скобка

Синтаксический анализатор C ++ 03 определяет «>>» как оператор сдвига вправо или оператор извлечения потока во всех случаях. Однако с вложенными объявлениями шаблонов программист имеет тенденцию пренебрегать помещением пробела между двумя прямыми угловыми скобками, что вызывает синтаксическую ошибку компилятора.

В C ++ 11 улучшена спецификация синтаксического анализатора, так что множественные прямые угловые скобки будут интерпретироваться как закрывающие список аргументов шаблона, где это целесообразно. Это можно изменить, заключив выражения параметров в круглые скобки с помощью бинарных операторов «>», «>=» или «>>:

шаблон класс SomeType; std :: vector 2>>x1; // Интерпретируется как std :: vector для SomeType , // за которым следует "2>>x1", что не является допустимым синтаксисом для декларатора. 1 верно. std :: vector 2)>>x1; // Интерпретируется как std :: vector для SomeType , // за которым следует декларатор «x1», что соответствует синтаксису C ++ 11. (1>2) ложно.

Операторы явного преобразования

В C ++ 98 добавлено ключевое слово явноев качестве модификатора для конструкторов, чтобы предотвратить использование конструкторов с одним аргументом в качестве операторов неявного преобразования типов. Однако это ничего не делает для реальных операторов преобразования. Например, класс интеллектуального указателя может иметь оператор bool (), чтобы он мог действовать больше как примитивный указатель: если он включает это преобразование, его можно протестировать с помощью if (smart_ptr_variable)(что было бы верно, если бы указатель был ненулевым, и ложным в противном случае). Однако это допускает и другие, непреднамеренные преобразования. Поскольку C ++ boolопределен как арифметический тип, его можно неявно преобразовать в целочисленные типы или даже типы с плавающей запятой, что позволяет выполнять математические операции, не предназначенные для пользователя.

В C ++ 11 ключевое слово явноетеперь можно применять к операторам преобразования. Как и в случае с конструкторами, он предотвращает использование этих функций преобразования в неявных преобразованиях. Однако языковые контексты, которым конкретно требуется логическое значение (условия операторов if и циклов, а также операнды логических операторов), считаются явными преобразованиями и, таким образом, могут использовать оператор преобразования типа bool.

Например, эта функция полностью решает проблему safe bool.

Псевдонимы шаблона

В C ++ 03 можно определить typedef только как синоним для другого типа, включая синоним для специализации шаблона со всеми указанными фактическими аргументами шаблона. Невозможно создать шаблон typedef. Например:

шаблон class SomeType; шаблон typedef SomeType TypedefName; // Недействительно в C ++ 03

Это не будет компилироваться.

C ++ 11 добавляет эту возможность с помощью следующего синтаксиса:

шаблон class SomeType; шаблон using TypedefName = SomeType ;

Синтаксис usingтакже может использоваться как псевдонимы типов в C ++ 11:

typedef void (* FunctionType) (double); // Старый стиль с использованием FunctionType = void (*) (double); // Новый введенный синтаксис

Неограниченные объединения

В C ++ 03 существуют ограничения на то, какие типы объектов могут быть членами union. Например, объединения не могут содержать никаких объектов, определяющих нетривиальный конструктор или деструктор. С ++ 11 снимает некоторые из этих ограничений.

Если член unionимеет нетривиальную специальную функцию-член, компилятор не будет генерировать эквивалентную функцию-член для union, и он должен быть определен вручную.

Это простой пример объединения, разрешенного в C ++ 11:

#include // Требуется для размещения 'new'. struct Point {Point () {} Point (int x, int y): x_ (x), y_ (y) {} int x_, y_; }; объединение U {int z; двойной ш; Пункт p; // Недействительно в C ++ 03; действует в C ++ 11. U () {} // Из-за члена Point теперь необходимо определение конструктора. U (const Point pt): p (pt) {} // Создаем объект Point, используя список инициализаторов. U оператор = (const Point pt) {new (p) Point (pt); вернуть * это; } // Назначаем объект Point, используя размещение 'новое'. };

Изменения не нарушат какой-либо существующий код, поскольку они только ослабят текущие правила.

Улучшения функциональности основного языка

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

Шаблоны с переменным числом параметров

В C ++ 11 шаблоны могут принимать переменное количество параметров шаблона. Это также позволяет определять типобезопасные вариативные функции.

Новые строковые литералы

C ++ 03 предлагает два типа строковых литералов. Первый тип, заключенный в двойные кавычки, создает массив с завершающим нулем типа const char. Второй тип, определенный как L "", создает массив с завершающим нулем типа const wchar_t, где wchar_t- расширенный символ неопределенного размера и семантика. Ни один из типов литералов не поддерживает строковые литералы с кодировками UTF-8, UTF-16 или другими типами кодировок Unicode .

Определение типа charбыл изменен, чтобы явно указать, что это, по крайней мере, размер, необходимый для хранения восьмибитного кода UTF-8, и достаточно большой, чтобы содержать любой член базовый набор символов выполнения компилятора. Раньше он определялся как последний в самом стандарте C ++, а затем полагался на стандарт C, чтобы гарантировать не менее 8 бит.

C ++ 11 поддерживает три кодировки Unicode: UTF-8, UTF-16 и UTF-32. Наряду с ранее отмеченными изменениями в определении char, C ++ 11 добавляет два новых типа символов: char16_tи char32_t. Они предназначены для хранения UTF-16 и UTF-32 соответственно.

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

u8 «Я - строка UTF-8». u "Это строка в кодировке UTF-16." U «Это строка в кодировке UTF-32».

Тип первой строки - обычный const char. Тип второй строки - const char16_t(обратите внимание на префикс u в нижнем регистре). Тип третьей строки - const char32_t(префикс U в верхнем регистре).

При построении строковых литералов Unicode часто бывает полезно вставить кодовые точки Unicode непосредственно в строку. Для этого C ++ 11 допускает такой синтаксис:

u8 «Это символ Юникода: \ u2018». u "Это более крупный символ Юникода: \ u2018." U "Это символ Юникода: \ U00002018."

Число после \ u- шестнадцатеричное число; ему не нужен обычный префикс 0x. Идентификатор \ uпредставляет собой 16-битную кодовую точку Unicode; для ввода 32-битной кодовой точки используйте \ Uи 32-битное шестнадцатеричное число. Можно вводить только действительные кодовые точки Unicode. Например, кодовые точки в диапазоне U + D800 – U + DFFF запрещены, поскольку они зарезервированы для суррогатных пар в кодировках UTF-16.

Также иногда полезно избегать экранирования строк вручную, особенно при использовании литералов файлов XML, языков сценариев или регулярных выражений. C ++ 11 предоставляет необработанный строковый литерал:

R "(The String Data \ Stuff") "R" разделитель (The String Data \ Stuff ") разделитель"

В первом случае, все между "(и )"является частью строки. Символы "и \не нужно экранировать. Во втором случае разделитель " (начинает строку и заканчивается только тогда, когда ) delimiter "достигнут. Строка delimiterможет быть любой строкой длиной до 16 символов, включая пустую строку. Эта строка не может содержать пробелы, управляющие символы, (, )или \символ. Использование этой строки разделителя позволяет пользователю иметь символы )в необработанных строковых литералах. Например, R "разделитель ((az)) разделитель"эквивалентно "(az)".

Необработанные строковые литералы можно комбинировать с широким литералом или любым из буквальных префиксов Unicode:

u8R "XXX (я -" необработанный UTF- 8 "строка.) XXX" uR "* (Это" необработанная строка UTF-16 ".) *" UR "(Это" необработанная строка UTF-32 ".)"

Определяется пользователем литералы

C ++ 03 предоставляет ряд литералов. Символы 12.5представляют собой литералы, которые компилятор разрешает как тип doubleсо значением 12,5. Однако добавление суффикса f, как в 12.5f, создает значение типа float, которое содержит значение 12.5. Модификаторы суффиксов для литералов фиксируются спецификацией C ++, а код C ++ 03 не может создавать новые модификаторы литералов.

Напротив, C ++ 11 позволяет пользователю определять новые виды модификаторов литералов, которые будут создавать объекты на основе строки символов, которые изменяет литерал.

Преобразование литералов переопределено на две отдельные фазы: необработанную и приготовленную. Необработанный литерал - это последовательность символов определенного типа, а готовый литерал - отдельного типа. Литерал C ++ 1234, как необработанный литерал, представляет собой последовательность символов '1', '2', '3', '4'. В качестве готового литерала это целое число 1234. Литерал C ++ 0xAв исходной форме равенство '0', 'x', 'A', в то время как в готовой форме это целое число 10.

Литералы могут быть расширены как в сырой, так и в готовой форме, за исключением строковых литералов, которые могут обрабатываться только в готовой форме. Это исключение связано с тем, что строки имеют префиксы, которые имеют значение на конкретное значение и рассматриваемые символы.

Все определяемые пользователем литералы являются суффиксами; определение префиксных литералов невозможно. Все суффиксы, начинающиеся с любого символа, кроме подчеркивания (_), зарезервированы стандартом. Таким образом, все определяемые используемые литералы должны иметь суффиксы, начинающиеся с символами который формируется (_).

Определяемые используемые литералы, обрабатываемые не обрабатываемые формула литерала, определяемые литеральным оператором, записывается как оператор "".

Оператор OutputType "" _mysuffix (const char * literal_string) {// предполагает, что OutputType имеет конструктор, который принимает const char * OutputType ret (literal_string); return ret;} OutputType some_variable = 1234_mysuffix; // предполагает, что OutputType имеет метод get_value (), который возвращает двойное утверждение (some_variable.get_value () == 1234.0)

Оператор присваивания OutputType some_variable = 1234_mysuffix;выполняет код, конкретную функцию. Эта функция передается "1234"как строка в стиле C, поэтому она имеет нулевой терминатор.

Альтернативный механизм для обработки исходных литералов с целыми числа и с плавающей запятой - через вариативный шаблон :

шаблон OutputType operator "" _tuffix (); OutputTy pe some_variable = 1234_tuffix; Тип вывода another_variable = 2.17_tuffix;

Создает экземпляр функции обработки литерала как operator "" _tuffix <'1', '2', '3', '4'>(). В этой нет нулевого символа в конце строки. Основная для этого - использовать используемое слово C ++ 11 constexpr, чтобы опасность, что компилятор полностью преобразует литерал во время компиляции, предполагаемая, OutputTypeявляется constexpr-конструктивным и копируемым типом, а функция обработки литерала - это функция constexpr.

Для числовых литералов типичного подготовленного литерала - либо unsigned long longдля целочисленных литералов, либо long doubleдля литералов с плавающей запятой. (Примечание: нет необходимости в целочисленных типах со знаком, поскольку литерал с префиксом анализируется как выражение, существее знак в виде формы оператора унарного префикса и беззнаковое число.) Альтернативной формы шаблона нет:

оператор OutputType "" _suffix (беззнаковый длинный длинный) ; OutputType operator "" _suffix (long double); Тип вывода some_variable = 1234_suffix; // Использует перегрузку unsigned long long. Тип вывода another_variable = 3.1416_suffix; // Использует перегрузку длинную двойную.

В соответствии с ранее указанными новыми строковыми префиксами для строковых литералов используются:

оператор OutputType "" _ssuffix (const char * string_values, size_t num_chars); OutputType operator "" _ssuffix (const wchar_t * string_values, size_t num_chars); OutputType operator "" _ssuffix (const char16_t * string_values, size_t num_chars); OutputType operator "" _ssuffix (const char32_t * string_values, size_t num_chars); OutputType some_variable = "1234" _ssuffix; // Использует перегрузку const char *. OutputType some_variable = u8 "1234" _ssuffix; // Использует перегрузку const char *. OutputType some_variable = L «1234» _ssuffix; // Использует перегрузку const wchar_t *. OutputType some_variable = u "1234" _ssuffix; // Использует перегрузку const char16_t *. OutputType some_variable = U "1234" _ssuffix; // Использует перегрузку const char32_t *.

Альтернативной формы нет. Символьные литералы определяется аналогично.

Модель многопоточной памяти

C ++ 11 стандартизирует поддержку многопоточного программирования.

Здесь задействованы две части: модель, которая позволяет нескольким потокам сосуществовать в программе и поддержка библиотеки для взаимодействия между потоками. (См. Этой статьи о средствах потоковой передачи.)

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

Локальное хранилище потока

В многопоточной среде каждый поток обычно имеет несколько уникальных чисел. Это уже происходит для глобальных и статических чисел.

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

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

Явно заданные по умолчанию и удаленные специальные функции конструктора

В C ++ 03 компилятор использует для классов, которые не предоставляют их для себя, по умолчанию, конструктор копирования, назначение копии оператор ( operator =) и деструктор. Программист может изменить эти значения по умолчанию, определив собственные версии. C ++ также определяет несколько глобальных операторов (таких как operator new), которые работают для всех классов, которые программист могут переопределить.

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

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

C ++ 11 допускает явную установку по умолчанию и удаление этих специальных функций-членов. Например, этот тип явно заявляет, что он использует конструктор по умолчанию:

struct SomeType {SomeType () = default; // Конструктор по умолчанию указан явно. SomeType (значение OtherType); };

Кроме того, некоторые функции можно отключить явным образом. Например, этот тип не подлежит копированию:

struct NonCopyable {NonCopyable () = default; NonCopyable (const NonCopyable ) = удалить; NonCopyable operator = (const NonCopyable ) = delete; };

Спецификатор = удалитькакое-то сообщение для запрета вызова любой функции, что может вызвать запрета функции члена с определенными заблокированными функциями. Например:

struct NoInt {void f (double i); void f (int) = удалить; };

Попытка вызвать f ()с intбудет отклоняться компилятором вместо выполнения тихого преобразования в double. Это можно обобщить, чтобы запретить вызов функции с любым типом, кроме doubleследующим образом:

struct OnlyDouble {void f (double d); шаблон void f (T) = delete; };

Тип long long int

В C ++ 03 самый большой целочисленный тип - long int. Гарантируется, что у него будет как минимум столько же используемых битов, сколько у int. Это привело к тому, что long intимел размер 64 бита в одних популярных реализациях и 32 бита в других. C ++ 11 новый целочисленный тип long long intдля решения этой проблемы. Гарантируется, что он будет не меньше, чем long int, и иметь не менее 64 бит. Тип введен C99 в стандарт C, и большинство компиляторов C ++ уже поддерживали его расширение.

Статические утверждения

C ++ 03 использует два метода для проверки утверждений : макрос assertи директива препроцессора #error. Однако ни то, ни другое не подходит для использования в шаблонах: макрос проверяет утверждение во время выполнения, в то время как директива препроцессора проверяет утверждение во время предварительной обработки, которая происходит до создания экземпляров шаблонов. Ни то, ни другое не подходит для тестирования свойств, зависящих от параметров шаблона.

Новая служебная программа представляет новый способ проверки утверждений во время компиляции с использованием нового ключевого слова static_assert. Объявление принимает следующую форму:

static_assert (выражение-константа, сообщение-ошибка);

Вот несколько примеров использования static_assert:

static_assert ((GREEKPI>3.14) (GREEKPI < 3.15), "GREEKPI is inaccurate!");

шаблон struct Check {static_assert (sizeof ( int) <= sizeof(T), "T is not big enough!"); };

шаблон Integral foo (Integral x, Integral y) {static_assert (std :: is_integral :: value, «параметр foo () должен быть целочисленного типа.»);}

Когда постоянное выражение false, компилятор выдает сообщение об ошибке. Первый пример аналогичен директиве препроцессора #error, хотя препроцессор поддерживает только целочисленные типы. Напротив, в во втором примере утверждение проверяется при каждом экземпляре класса шаблона Проверить.

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

Разрешить size ofдля работы с членами классов б ез явного объекта

В C ++ 03 оператор sizeof может использоваться для типов и объектов. Но его нельзя использовать для этого:

struct SomeType {OtherType member; }; sizeof (SomeType :: member); // Не работает с C ++ 03. Хорошо с C ++ 11

Это должно вернуть размер OtherType. C ++ 03 запрещает это, поэтому это ошибка компиляции. C ++ 11 позволяет это. Это также разрешено для оператора alignof, представленного в C ++ 11.

Выравнивание объекта управления и запроса

C ++ 11 позволяет запрашивать и контролировать выравнивание переменных с помощью alignofи alignas.

alignof Операторпринимает тип и возвращает степень 2-байтовой границы, на которой должны быть размещены экземпляры типа (как std :: size_t). При задании ссылочного типа alignofвозвращает выравнивание ссылочного типа; для массивов возвращает выравнивание типа элемента.

Спецификатор alignasуправляет выравниванием памяти для переменной. Спецификатор принимает константу или тип; при поставке тип alignas (T)является сокращением для alignas (alignof (T)). Например, чтобы указать, что массив символов должен быть правильно выровнен для хранения числа с плавающей запятой:

alignas (float) unsigned char c [sizeof (float)]

Разрешить реализации со сборкой мусора

Предыдущие стандарты C ++ предусмотрена для управляемой программистом сборки мусора через set_new_handler, но не дает определения достижимости объекта с целью автоматической сборки мусора. C ++ 11 определяет условия, при которых значения указателя «безопасно выводятся» из других значений. Реализация может указывать, что она работает со строгой безопасностью указателей, и в этом случае указатели, которые не получены в соответствии с этими правилами, могут стать недействительными.

Атрибуты

C ++ 11 предоставляет стандартизированный синтаксис для расширений компилятора / инструментальных средств языка. Такие расширения традиционно указывались с помощью директивы #pragmaили ключевых слов производителя (например, __attribute__для GNU и __declspecдля Microsoft). С новым синтаксисом добавленная информация может быть указана в форме атрибута, заключенного в двойные квадратные скобки. Атрибут может применяться к различным элементам исходного кода:

int [[attr1]] i [[attr2, attr3]]; [[attr4 (arg1, arg2)]] если (cond) {[[vendor :: attr5]] return i; }

В приведенном выше примере атрибут attr1применяется к типу переменной i, attr2, а attr3применяется к самой переменной, attr4применяется к оператору if, а vendor :: attr5применяется к оператору return. В общем (но с некоторыми исключениями) атрибут, указанный для именованного объекта, помещается после имени, а перед объектом, в противном случае, как показано выше, несколько атрибутов могут быть перечислены в одной паре двойных квадратных скобок, могут быть предоставлены дополнительные аргументы для атрибута, а атрибуты могут быть охвачены пространством имен атрибутов, зависящим от поставщика.

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

C ++ 11 сам предоставляет два стандартных атрибута: noreturn, чтобы указать, что функция не возвращает, и supports_dependency, чтобы помочь оптимизировать многопоточный код, указывая, что аргументы функции или возвращаемое значение несут зависимость.

В стандартную библиотеку C ++ 11 введен ряд новых функций. Многие из них можно было бы реализовать в соответствии со старым стандартом, но некоторые полагаются (в большей или меньшей степени) на новые основные функции C ++ 11.

Большая часть новых библиотек была определена в документе Технический отчет Комитета по стандартам C ++ (называемый TR1), который был опубликован в 2005 г. Различные полные и частичные реализации TR1 в настоящее время доступны с использованием пространства имен std :: tr1. Для C ++ 11 они были перемещены в пространство имен std. Однако, поскольку функции TR1 были добавлены в стандартную библиотеку C ++ 11, они были обновлены там, где это необходимо, с помощью функций языка C ++ 11, которые не были доступны в начальной версии TR1. Кроме того, они могли быть расширены функциями, которые были возможны в C ++ 03, но не были частью исходной спецификации TR1.

Обновления до компонентов стандартной библиотеки

C ++ 11 предлагает ряд новых языковых функций, которыми могут воспользоваться существующие в настоящее время компоненты стандартной библиотеки. Например, большинство стандартных библиотечных контейнеров могут выиграть от поддержки конструктора перемещения на основе ссылок Rvalue как для быстрого перемещения тяжелых контейнеров, так и для перемещения содержимого этих контейнеров в новые места в памяти. Компоненты стандартной библиотеки были обновлены новыми функциями языка C ++ 11, где это необходимо. К ним относятся, но не обязательно ограничиваются:

• ссылки Rvalue и соответствующая поддержка перемещения
• Поддержка блока кодирования UTF-16 и блока кодирования UTF-32 Типы символов Unicode
• Вариативные шаблоны (в сочетании со ссылками на Rvalue для обеспечения идеальной пересылки)
• Выражения констант времени компиляции
• decltype
• явныеоператоры преобразования
• Функции, объявленные по умолчанию или удаленные

Кроме того, прошло много времени с момента выхода предыдущего стандарта C ++. Написано много кода с использованием стандартной библиотеки. Это выявило части стандартных библиотек, которые можно было бы улучшить. Среди множества рассмотренных улучшений были стандартные библиотечные распределители. Новая модель распределителей на основе области видимости была включена в C ++ 11 в дополнение к предыдущей модели.

Возможности потоковой передачи

Хотя язык C ++ 03 предоставляет модель памяти, поддерживающую многопоточную обработку, основная поддержка фактического использования потоковой передачи обеспечивается стандартной библиотекой C ++ 11.

Предоставляется класс потока (std :: thread), который принимает объект функции (и дополнительную серию аргументов для передачи ему) для запуска в новый поток. Можно вызвать остановку потока до тех пор, пока другой выполняющийся поток не завершится, обеспечивая поддержку присоединения потока через функцию-член std :: thread :: join (). Доступ предоставляется, где это возможно, к базовому объекту (объектам) собственного потока для операций, связанных с платформой , с помощью функции-члена std :: thread :: native_handle ().

Для синхронизации между потоками, соответствующие мьютексы (std :: mutex, std :: recursive_mutexи т. Д.) И условие переменные (std :: condition_variableи std :: condition_variable_any) добавляются в библиотеку. Они доступны с помощью блокировок Resource Acquisition Is Initialization (RAII) (std :: lock_guardи std :: unique_lock) и алгоритмов блокировки для простоты использования.

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

Библиотека потоков C ++ 11 также включает фьючерсы и обещания для передачи асинхронных результатов между потоками и std :: packaged_taskдля завершения вызова функции, которая может генерировать такой асинхронный результат. Предложение о фьючерсах подверглось критике, поскольку в нем отсутствует способ комбинировать фьючерсы и проверять выполнение одного обещания внутри набора обещаний.

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

Новое средство std :: asyncпредоставляет удобный метод запуска задач и привязки их к std :: future. Пользователь может выбрать, будет ли задача выполняться асинхронно в отдельном потоке или синхронно в потоке, ожидающем значения. По умолчанию реализация может выбирать, что обеспечивает простой способ воспользоваться преимуществами аппаратного параллелизма без превышения лимита подписки и предоставляет некоторые преимущества пула потоков для простого использования.

Типы кортежей

Кортежи - это коллекции, состоящие из разнородных объектов предварительно упорядоченных измерений. Кортеж можно рассматривать как обобщение переменных-членов структуры.

Версия кортежа TR1 для C ++ 11 использует такие функции C ++ 11, как вариативные шаблоны. Для разумной реализации версии TR1 требовалось максимальное количество содержащихся типов, определяемое реализацией, и существенная уловка макросов. Напротив, реализация версии C ++ 11 не требует явного максимального количества типов, определяемых реализацией. Хотя компиляторы будут иметь внутреннюю максимальную глубину рекурсии для создания экземпляров шаблона (что нормально), версия кортежей C ++ 11 не будет предоставлять это значение пользователю.

Используя вариационные шаблоны, объявление класса кортежа выглядит следующим образом:

шаблон кортеж класса;

Пример определения и использования типа кортежа:

typedef std :: tuple test_tuple; long longy = 12; test_tuple proof (18, 6.5, длинный, «Чао!»); longy = std :: get <0>(доказательство); // Присваиваем 'longy' значение 18. std :: get (proof) = "Beautiful!"; // Изменяем четвертый элемент кортежа.

Можно создать кортеж proofбез определения его содержимого, но только если типы элементов кортежа имеют конструкторы по умолчанию. Более того, можно назначить кортеж другому кортежу: если типы двух кортежей одинаковы, каждый тип элемента должен иметь конструктор копирования; в противном случае каждый тип элемента правого кортежа должен быть конвертируемым в соответствующий тип элемента левого кортежа или чтобы соответствующий тип элемента левого кортежа имел подходящий конструктор.

typedef std :: tuple tuple_1 t1; typedef std :: tuple tuple_2 t2 ('X', 2, «Привет!»); t1 = t2; // Хорошо, первые два элемента могут быть преобразованы, // третий может быть построен из 'const char *'.

Так же, как std :: make_pairдля std :: pair, существует std :: make_tupleдля автоматического создания std :: tupleс использованием вывода типа, а autoпомогает объявить такой кортеж. std :: tieсоздает кортежи ссылок lvalue для помощи при распаковке кортежей. std :: ignoreтакже здесь помогает. См. Пример:

auto record = std :: make_tuple («Хари Рам», «Нью-Дели», 3.5, 'A'); std :: string name; float gpa; сорт char; std :: tie (имя, std :: ignore, gpa, оценка) = запись; // std :: ignore помогает отбросить имя места std :: cout << name << ' ' << gpa << ' ' << grade << std::endl ;

Доступны реляционные операторы (среди кортежей с одинаковым количеством элементов), и доступны два выражения для проверки характеристик кортежа (только во время компиляции):

• std :: tuple_size :: valueвозвращает количество элементов в кортеже T,
• std :: tuple_element :: typeвозвращает тип объекта номер Iкортежа T.

Хеш-таблицы

Включение хэш-таблиц (неупорядоченных ассоциативных контейнеров) в стандартную библиотеку C ++ - один из самых повторяющихся запросов. Он не был принят в C ++ 03 только из-за нехватки времени. Хотя хеш-таблицы менее эффективны, чем сбалансированное дерево в худшем случае (при наличии множества коллизий), они лучше работают во многих реальных приложениях.

Конфликты управляются только с помощью линейной цепочки, потому что комитет не счел целесообразным стандартизировать решения открытой адресации, которые создают довольно много внутренних проблем (прежде всего, когда допускается стирание элементов). Чтобы избежать конфликтов имен с нестандартными библиотеками, которые разработали свои собственные реализации хеш-таблиц, вместо «хеша» использовался префикс «неупорядоченный».

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

Новые классы удовлетворяют всем требованиям контейнерного класса и имеют все методы, необходимые для доступа к элементам: insert, erase, begin, end.

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

Регулярные выражения

Новая библиотека, определенная в новом заголовке , состоит из пары новых классов:

• регулярные выражения представлены экземпляром класс шаблона std :: regex;
• вхождения представлены экземпляром класса шаблона std :: match_results.

Функция std :: regex_searchиспользуется для поиска, а для «поиск и замена» используется функция std :: regex_replace, которая возвращает новую строку. Алгоритмы std :: regex_searchи std :: regex_replaceпринимают регулярное выражение и строку и записывают вхождения, найденные в struct std :: match_results.

Вот пример использования std :: match_results:

const char * reg_esp = "[,. \\ t \\ n ;:]"; // Список символов-разделителей. // это можно сделать с помощью необработанных строковых литералов: // const char * reg_esp = R "([,. \ t \ n ;:])"; std :: regex rgx (reg_esp); // 'regex' - это экземпляр класса шаблона // 'basic_regex' с аргументом типа 'char'. std :: cmatch match; // cmatch - это экземпляр класса шаблона // match_results с аргументом типа const char *. const char * target = "Невидимый университет - Анк-Морпорк"; // Идентифицирует все слова 'target', разделенные символами 'reg_esp'. if (std :: regex_search (target, match, rgx)) {// Если присутствуют слова, разделенные указанными символами. const size_t n = match.size (); for (size_t a = 0; a < n; a++) { std::string str (match[a].first, match[a].second); std::cout << str << "\n"; } }

Обратите внимание на использование двойных обратных косых черт, потому что C ++ использует обратную косую черту как escape-символ. Можно использовать функцию C ++ 11 необработанной строки чтобы избежать проблемы.

Библиотека не требует ни изменения какого-либо существующего заголовка (хотя он будет использовать их там, где это необходимо), ни расширения основного языка. В POSIX C, регулярные выражения также доступны в C POSIX library # regex.h.

Универсальные интеллектуальные указатели

C ++ 11 предоставляет std :: unique_ptrи улучшения для std :: shared_ptrи std :: weak_ptrиз TR1. std :: auto_ptrне рекомендуется.

Расширяемое средство случайных чисел

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

Функциональные возможности случайных чисел C ++ 11 разделены на две части: механизм генератора, который содержит состояние генератора случайных чисел и производит псевдослучайные числа; и распределение, которое определяет диапазон и математическое распределение результата. Эти два элемента объединены в объект генератора случайных чисел.

В отличие от стандарта C rand, механизм C ++ 11 будет иметь три базовых алгоритма движка генератора:

• linear_congruential_engine ,
• subtract_with_carry_engine и
• mersenne_twister_engine .

C ++ 11 также предоставляет ряд стандартных распределений:

• uniform_int_distribution ,
• uniform_real_distribution ,
• bernoulli_distribution ,
• биномиальное_распределение ,
• геометрическое_распределение ,
• отрицательное_биномиальное_распределение ,
• отрицательное_биномиальное_распределение ,
• отрицательное_биномиальное_распределение ,
• ,
• gamma_distribution ,
• weibull_distribution ,
• extreme_value_distribution ,
• normal_distribution ,
• lognormal_distribution ,
• chi_squared_distribution ,
• cauchy_distribution ,
• fisher_f_distribution1<дистрибутивы1 и
• piecewise_linear_distribution .

Генератор и распределения объединены, как в этом примере:

#include #include std :: uniform_int_distribution distr ibution (0, 99); std :: mt19937 двигатель; // Автогенератор Mersenne Twister MT19937 = std :: bind (distribution, engine); int random = генератор (); // Генерация однородного интеграла с вариацией от 0 до 99. int random2 = distribution (engine); // Сгенерировать другой образец напрямую, используя объекты распределения и движка.

Ссылка на оболочку

A Ссылка на оболочку получается из экземпляра класса шаблона reference_wrapper. Ссылки-оболочки аналогичны обычным ссылкам (‘’) языка C ++. Для получения ссылки на оболочку из любого объекта используется шаблон функции ref(для постоянной ссылки используется cref).

// Эта функция получит ссылку на параметр 'r' и увеличит ее. void func (int r) {r ++; } // Шаблонная функция. шаблон void g (F f, P t) {f (t); } int main () {int я = 0; г (функция, я); // 'g ' создается // тогда 'i' не будет изменяться. std :: cout << i << std::endl; // Output ->0 g (func, std :: ref (i)); // 'g >' создается // тогда 'i' будет изменен. std :: cout << i << std::endl; // Output ->1}

std :: function func; // Создание оболочки с использованием // класса шаблона 'function'. std :: plus добавить; // 'плюс' объявлен как 'template T plus (T, T);' // тогда 'add' имеет тип 'int add (int x, int y)'. func = add; // ОК - параметры и возвращаемые типы совпадают. int a = func (1, 2); // ПРИМЕЧАНИЕ: если оболочка func не ссылается на какую-либо функцию, // генерируется исключение std :: bad_function_call. std :: function func2; if (! func2) {// Истина, потому что функции 'func2' еще не присвоена функция. bool смежный (long x, long y); func2 = смежный; // ОК - параметры и возвращаемые типы можно преобразовать. struct Test {bool operator () (короткий x, короткий y); }; Тестовая машина; func = std :: ref (автомобиль); // 'std :: ref' - это шаблонная функция, которая возвращает оболочку // функции-члена 'operator ()' структуры 'car'. } func = func2; // ОК - параметры и возвращаемые типы можно преобразовать.

template struct Pow { // рекурсивный вызов и рекомбинация. перечисление {значение = B * Pow :: значение}; }; template < int B>struct Pow {// '' N == 0 '' условие завершения. перечисление {значение = 1}; }; int quartic_of_three = Pow <3, 4>:: значение;

// Первый способ работы. шаблон < bool B>struct Algorithm {template static int do_it (T1, T2 ) {/*...*/}}; // Второй способ работы. template<>struct Algorithm{ templatestatic int do_it (T1, T2) { /*...*/ } }; // Instantiating 'elaborate' will automatically instantiate the correct way to operate. templateint elaborate (T1 A, T2 B) { // Use the second way only if 'T1' is an integer and if 'T2' is // in floating point, otherwise use the first way. return Algorithm::value std::is_floating_point::value>::do_it( A, B) ; }

struct Clear { int operator()(int) const; // The parameter type is double operator()(double) const; // equal to the return type. }; template class Calculus { public: templateArg operator()(Arga) const { return member(a); } private: Obj member; };

struct Confused { double operator()(int) const; // The parameter type is not int operator()(double) const; // equal to the return type. };

template< class Obj>class CalculusVer2 { public: templatetypename std::result_of::type operator()(Arga) const { return member(a); } private: Obj member; };