Скотт Мейерс - Эффективный и современный С++. 42 рекомендации по использованию С++11 и С++14

// Вывод информации о Т

cout << "Т = "

<< type_id_with_cvr().pretty_name()

<< '\n';

// Вывод информации о типе param

cout << "param = "

<< type_id_with_cvr().pretty_name()

<< '\n';

}

Как это работает? Шаблон функции boost::typeindex::type_id_with_cvrполучает аргумент типа (тип, о котором мы хотим получить информацию) и не удаляет const, volatileили квалификатор ссылки (о чем и говорит “ with_cvr” в имени шаблона). Результатом является объект boost::typeindex::type_index, функция-член pretty_nameкоторого дает std::stringс удобочитаемым представлением типа.

При такой реализации fобратимся вновь к вызову, который давал нам неверную информацию о типе paramпри использовании typeid:

std::vector createVec(); // Фабричная функция

const auto vw = createVec(); // Инициализация vw с помощью

// фабричной функции

if (!vw.empty()) {

f(&vw[0]); // Вызов f

}

После компиляции с помощью компиляторов GNU и Clang Boost.TypeIndex дает следующий (точный) результат:

Т = Widget const*

param = Widget const* const&

Применение компилятора Microsoft дает по сути то же самое:

Т = class Widget const *

param = class Widget const * const &

Такое единообразие — это хорошо, но важно помнить, что редакторы IDE, сообщения об ошибках компилятора и библиотеки наподобие Boost.TypeIndex являются всего лишь инструментами, которые можно использовать для выяснения того, какие типы выводит ваш компилятор. Это может быть полезно, но не может заменить понимания информации о выводе типов, приведенной в разделах 1.1–1.3.

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

• Результаты, которые выдают некоторые инструменты, могут оказаться как неточными, так и бесполезными, так что понимание правил вывода типов в С++ является совершенно необходимым.

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

Легко и радостно написать

int x;

Стоп! #@$! Я забыл инициализировать x, так что эта переменная имеет неопределенное значение. Может быть. Но она может быть инициализирована и нулем — в зависимости от контекста. Жуть!

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

template // Некий алгоритм, работающий с

void dwim(It b, It e) // элементами из диапазона от b до e

{

while (b != e) {

typename std::iterator_traits::value_type

currValue = *b;

}

}

Жуть. typename std::iterator_traits::value_type— просто чтобы записать тип значения, на которое указывает итератор? Нет, я такой радости не переживу… #@$! Или я это уже говорил?..

Ладно, третья попытка. Попробую объявить локальную переменную, тип которой такой же, как у лямбда-выражения. Но его тип известен только компилятору. #@$! (Это становится привычкой…)

Да что же это такое — никакого удовольствия от программирования на С++! Так не должно быть. И не будет! Мы дождались С++11, в котором все эти проблемы решены с помощью ключевого слова auto. Тип переменных, объявленных как auto, выводится из их инициализатора, так что они обязаны быть инициализированными. Это значит — прощай проблема неинициализированных переменных:

intx1; // Потенциально неинициализированная переменная

autox2; // Ошибка! Требуется инициализатор

autox3 = 0; // Все отлично, переменная x корректно определена

Нет проблем и с объявлением локальной переменной, значением которой является разыменование итератора:

template // Все, как и ранее

void dwim(It b, It e) {

while (b != e) {

autocurrValue = *b;

}

}

А поскольку autoиспользует вывод типов (см. раздел 1.2), он может представлять типы, известные только компиляторам:

autoderefUPLess = // Функция сравнения

[](const std::unique_ptr& p1, // объектов Widget, на

const std::unique_ptr& p2) // которые указывают

{ return *p1 < *p2; ); // std::unique_ptr

Просто круто! В С++14 все еще круче, потому что параметры лямбда-выражений также могут включать auto:

auto derefLess = // Функция сравнения в С++14,

[](const auto& p1, // для значений, на которые

const auto& p2) // указывает что угодно

{ return *p1 < *p2; }; // указателеобразное

Несмотря на всю крутость вы, вероятно, думаете, что можно обойтись и без autoдля объявления переменной, которая хранит лямбда-выражение, поскольку мы можем использовать объект std::function. Это так, можем, но, возможно, это не то, что вы на самом деле подразумеваете. А может быть, вы сейчас думаете “А что это такое — объект std::function?” Давайте разбираться.

std::function— шаблон стандартной библиотеки С++11, который обобщает идею указателя на функцию. В то время как указатели на функции могут указывать только на функции, объект std::functionможет ссылаться на любой вызываемый объект, т.e. на все, что может быть вызвано как функция. Так же как при создании указателя на функцию вы должны указать тип функции, на которую указываете (т.e. сигнатуру функции, на которую хотите указать), вы должны указать тип функции, на которую будет ссылаться создаваемый объект std::function. Это делается с помощью параметра шаблона std::function. Например, для объявления объекта std::functionс именем func, который может ссылаться на любой вызываемый объект, действующий так, как если бы его сигнатура была

bool(const std::unique_ptr&, // Сигнатура C++11 для

const std::unique_ptr&) // функции сравнения

// std::unique_ptr

следует написать следующее:

std::function< bool(const std::unique_ptr&,

const std::unique_ptr&)> func;

Поскольку лямбда-выражения дают вызываемые объекты, замыкания могут храниться в объектах std::function. Это означает, что можно объявить С++11-версию derefUPLessбез применения autoследующим образом: