C++14

Материал из Википедии — свободной энциклопедии
Перейти к: навигация, поиск

C++14 — неофициальное название последней версии стандарта C++ ISO/IEC JTC1 (полное название: «International Standard ISO/IEC 14882:2014(E) Programming Language C++»). C++14 можно рассматривать как небольшое расширение над C++11, содержащее в основном исправления ошибок и небольшие улучшения. Комитет разработки нового стандарта опубликовал черновик N3690 15 мая 2013[1]. Рабочая версия черновика N3936 была опубликована 2 марта 2014 года, заключительный период голосования закрыт 15 августа 2014 года, а результат (единогласное одобрение) был объявлен 18 августа 2014 года[2].

Поскольку разработка стандарта была длительной, а год выпуска итоговой версии не был определён, в ходе разработки также использовалось имя «C++1y», аналогично тому, как стандарт C++11 до его выпуска называли «C++0x» (выпуск этой версии ожидался до 2010 года).

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

Изменения в языке[править | править вики-текст]

В этом разделе приведены новые возможности ядра языка в C++14.

Вывод типа возвращаемого значения для функций[править | править вики-текст]

C++11 позволяет выводить тип возвращаемых значений для лямбда-функций из типа возвращаемого выражения. C++14 расширяет эту возможность на все функции. Новый стандарт также описывает вывод типов для лямбда-функций, с видом, отличным от return expression;[3].

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

auto DeduceReturnType(); // тип возвращаемого значение будет определён позже.

Если в теле функции в разных местах возвращаются несколько выражений, все эти выражения должны иметь общий выводимый тип[4].

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

В таких функциях возможно использовать рекурсию, но рекурсивный вызов должен выполняться хотя бы после одного возврата значения в этой функции[4]:

auto Correct(int i) {
 if (i == 1)
 return i; // в качестве типа возвращаемого значения выводится int
 else
 return Correct(i-1)+i; // теперь можно вызывать
}
 
auto Wrong(int i) {
 if(i != 1)
 return Wrong(i-1)+i; // неподходящее место для рекурсии. Нет предшествующего возврата.
 else
 return i; // в качестве типа возвращаемого значения выводится int
}

Альтернативный вывод типа при объявлении[править | править вики-текст]

В C++11 были добавлены два способа вывода типов. auto позволял создавать переменные с типом на основе присваиваемого выражения. decltype позволял определить результирующий тип произвольного выражения. Однако типы, выводимые decltype и auto, отличались между собой. В частности, auto всегда выводит не-ссылочный тип, как если бы был обработан std::remove_reference, тогда как auto&& всегда выводит ссылочный тип. Тем не менее, результатом decltype может быть как ссылочный тип, так и не-ссылочный, в зависимости обрабатываемого выражения[3]:

int i;
int&& f();
auto x3a = i; // decltype(x3a) - int
decltype(i) x3d = i; // decltype(x3d) - int
auto x4a = (i); // decltype(x4a) - int
decltype((i)) x4d = (i); // decltype(x4d) - int&
auto x5a = f(); // decltype(x5a) - int
decltype(f()) x5d = f(); // decltype(x5d) - int&&

В C++14 добавлен синтаксис decltype(auto). Этот синтаксис позволяет использовать правила decltype для объявлений auto.

Синтаксис decltype(auto) также можно использовать для вывода типов возвращаемых значений, если указать decltype(auto) вместо auto на месте типа возвращаемого значения функции[4].

Уменьшение ограничений на константные выражения[править | править вики-текст]

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

В C++14 эти ограничения частично сняты. Constexpr-функции теперь могут содержать следующие элементы[3]:

  • Любые объявления, кроме:
    • static или thread_local переменных;
    • объявлений переменных без инициализаторов;
    • goto-выражений.
  • Условные выражения ветвления if и switch.
  • Все операторы циклов, в том числе for для диапазонов.
  • Выражения могут изменять значения объектов, если время жизни этих объектов началось в constexpr-функции. К этому относятся также вызовы любых не-const constexpr нестатических функций-членов.


Ограничения на вызов не-constexpr-функций остаются в силе. Таким образом, если используется for для диапазонов, функции begin и end контейнеров должны быть перегружены как constexpr. Для встроенного типа std::initializer_list функции begin/end определены как constexpr, как локально, так и глобально.

Кроме того, в C++11 все нестатические методы, объявленные с constexpr, неявно считались const-функциями по отношению к this. Это ограничение снято; нестатические методы теперь могут быть не const[5]. Тем не менее, как упомянуто ранее, не-const constexpr-метод может изменить поля класса только в том случае, если время жизни этого объекта началось в ходе вычисления константного выражения.

Шаблоны переменных[править | править вики-текст]

В предыдущих версиях C++ шаблонизация применялась только для функций и классов. C++14 позволяет создавать шаблонные переменные. В примере из предложения приводится шаблон переменной pi, к которому можно обратиться, чтобы получить значение числа пи для различных типов (например, 3, при чтении целого типа; наиболее близкое значение к float , double или long double при чтении как float , double или long double , соответственно, и т. д.).

К таким объявлениям и определениям относятся обычные правила шаблонов, в том числе правила специализации[6][7].

Агрегатная инициализация классов с инициализаторами полей[править | править вики-текст]

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

C++14 снимает это ограничение[3] и разрешает агрегатную инициализацию классов с инициализаторами полей. Если список инициализаторов в фигурных скобках не предоставляет значение для этого аргумента, то работу на себя возьмёт инициализатор поля[8].

Литералы двоичных чисел[править | править вики-текст]

Числовые литералы в C++14 можно указать в двоичной форме[3]. Синтаксис использует префиксы 0b или 0B. Схожий синтаксис также используется в Java, Python, Perl и D.

Разделители разрядов[править | править вики-текст]

В C++14 можно использовать апостроф для произвольного разделения разрядов в числовых литералах[9]. В некоторых случаях это упрощает восприятие больших числовых констант в коде и улучшает читаемость кода.

auto integer_literal = 1'000'000;
auto floating_point_literal = 0.000'015'3;
auto binary_literal = 0b0100'1100'0110;
auto silly_example = 1'0'0'000'00;

Обобщённые лямбда-функции[править | править вики-текст]

В C++11 параметры лямбда-функций требовалось объявлять с указанием конкретных типов. C++14 снимает это ограничение и позволяет объявлять параметры лямбда-функций со спецификатором типа auto[6].

auto lambda = [](auto x, auto y) {return x + y;};

Выведение типов параметров обобщённых лямбда-функций выполняется по правилам, схожим с выведением типов для auto-переменных (но не является полностью идентичным). Приведённый выше код эквивалентен следующему[10]:

struct unnamed_lambda
{
 template<typename T, typename U>
 auto operator()(T x, U y) const {return x + y;}
};
auto lambda = unnamed_lambda();

Захват выражений для лямбда-функций[править | править вики-текст]

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

Захват выражений осуществляется с помощью инициализаторов:

auto lambda = [value = 1] {return value;};

Лямбда-функция lambda вернёт 1, так как для параметра value сработал соответствующий инициализатор. Тип захватываемого параметра выводится из типа инициализатора, подобно объявлению переменной со спецификатором auto.

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

std::unique_ptr<int> ptr(new int(10));
auto lambda = [value = std::move(ptr)] {return *value;};

Новые функции стандартной библиотеки[править | править вики-текст]

Разделяемые мьютексы и блокировки[править | править вики-текст]

В C++14 добавлены разделяемые (shared) мьютексы и новый тип блокировки для таких мьютексов[12][13].

Гетерогенный поиск в ассоциативных контейнерах[править | править вики-текст]

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

C++14 позволяет индексировать ассоциативные контейнеры значением произвольного типа при условии, что имеется перегруженный оператор сравнения, который может сравнивать значение этого типа со значением типа ключа контейнера[14]. Это позволяет индексировать map-контейнеры с типом ключа std::string выражениями типа const char* с использованием перегруженного оператора сравнения operator<.

Для сохранения обратной совместимости, гетерогенный поиск допускается только тогда, когда компаратор, передаваемый ассоциативному контейнеру, поддерживает такой поиск. Классы стандартной библиотеки std::less (по умолчанию для set- и map-контейнеров) и std::greater позволяют осуществлять гетерогенный поиск[15].

Стандартные пользовательские литералы[править | править вики-текст]

В C++11 описан синтаксис определяемых пользователем литеральных суффиксов, но ни один из них не используется в стандартной библиотеке. C++14 добавляет следующие стандартные литералы[14]:

  • «s» для создания различных std::basic_string типов.
  • «h», «min», «s», «ms», «us» и «ns» для создания соответствующих временных интервалов std::chrono::duration.
string str = "hello world"s;
chrono::duration dur = 60s;

Два литерала «s» не влияют друг на друга, поскольку строковой литерал работает только на строками, а секундный действует только на числа[16].

Адресация к кортежам по типу[править | править вики-текст]

std::tuple, введённый в C++11, позволяет агрегировать несколько типизированных значений, которые будут проиндексированы во время компиляции. C++14 расширяет функционал кортежей для возможности обращения к элементам кортежа не только по индексу, но и по типу[14]. Если кортеж содержит более одного элемента запрашиваемого типа, поиск приведёт к ошибке компиляции[17]:

tuple<string, string, int> t("foo", "bar", 7);
int i = get<int>(t); // i == 7
int j = get<2>(t); // то же, что и раньше: j == 7
string s = get<string>(t); // ошибка компиляции из-за неоднозначности

Прочие изменения стандартной библиотеки[править | править вики-текст]

std::make_unique можно использовать так же, как и std::make_shared для объектов std::unique_ptr[6].

Для std::integral_constant добавлен перегруженный operator(), возвращающий константное значение[14].

По аналогии с глобальными функциями std::begin/std::end добавлены функции std::cbegin/std::cend, которые возвращают константные итераторы на начало и конец диапазона.

См. также[править | править вики-текст]

Примечания[править | править вики-текст]

  1. Committee Draft, Standard for Programming Language C++ (PDF). ISO (15 мая 2013).
  2. Sutter, Herb (August 18, 2014), «We have C++14!», <https://isocpp.org/blog/2014/08/we-have-cpp14>. Проверено 18 августа 2014. 
  3. 1 2 3 4 5 Wong, Michael The View from the C++ Standard meeting April 2013 Part 3. C/C++ Cafe (30 апреля 2013). Проверено 14 июня 2013.
  4. 1 2 3 Merrill, Jason N3638 Return type deduction for normal functions (Revision 5) (17 апреля 2013). Проверено 14 июня 2013.
  5. Smith, Richard N3652 Relaxing constraints on constexpr functions (18 апреля 2013).
  6. 1 2 3 4 Саттер, Герб Trip Report: ISO C++ Spring 2013 Meeting (20 апреля 2013). Проверено 14 июня 2013.
  7. Dos Reis, Gabriel N3651 Variable Templates (Revision 1) (PDF) (19 апреля 2013).
  8. N3653 Member initializers and aggregates (17 апреля 2013).
  9. N3781 Single-Quotation-Mark as a Digit Separator (25 September 2013).
  10. N3649 Generic (Polymorphic) Lambda Expressions (Revision 3) (19 апреля 2013).
  11. Move capture in Lambda.
  12. Wong, Michael The View from the C++ Standard meeting April 2013 Part 3. C/C++ Cafe (30 апреля 2013). Проверено 14 июня 2013.
  13. N3659 Shared locking in C++ (Revision 2) (19 апреля 2013).
  14. 1 2 3 4 Wong, Michael The View from the C++ Standard meeting April 2013 Part 2. C/C++ Cafe (26 апреля 2013). Проверено 14 июня 2013.
  15. N3657 Adding heterogeneous comparison lookup to associative containers (rev 4) (19 марта 2013).
  16. Peter, Sommerlad N3642 User-defined Literals for Standard Library Types (part 1 - version 4) (PDF) (18 апреля 2013).
  17. Spertus, Mike N3670 Wording for Addressing Tuples by Type: Revision 2 (19 апреля 2013).