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

Даже без упоминания С++14 в С++11 есть что поизучать.

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

Информация в книге разбита на отдельные разделы, посвященные тем или иным рекомендациям. Вы хотите разобраться в разных видах вывода типов? Или хотите узнать, когда следует (а когда нет) использовать объявление auto? Вас интересует, почему функция-член, объявленная как const, должна быть безопасна с точки зрения потоков, как реализовать идиому Pimpl с использованием std::unique_ptr, почему следует избегать режима захвата по умолчанию в лямбда-выражениях или в чем различие между std::atomicи volatile? Ответы на эти вопросы вы найдете в книге. Более того, эти ответы не зависят от платформы и соответствуют стандарту. Это книга о переносимом С++.

Разделы книги представляют собой рекомендации, а не жесткие правила, поскольку рекомендации имеют исключения. Наиболее важной частью каждого раздела является не предлагаемая в нем рекомендация, а ее обоснование. Прочитав раздел, вы сможете сами определить, оправдывают ли обстоятельства вашего конкретного проекта отход от данной рекомендации. Истинная цель книги не в том, чтобы рассказать вам, как надо поступать или как поступать не надо, а в том, чтобы обеспечить вас более глубоким пониманием, как та или иная концепция работает в С++11 и С++14.

Чтобы мы правильно понимали друг друга, важно согласовать используемую терминологию, начиная, как ни странно это звучит, с термина “С++”. Есть четыре официальные версии С++, и каждая именуется с использованием года принятия соответствующего стандарта ISO: С++98, C++03, C++11 и С++14. С++98 и C++03 отличаются один от другого только техническими деталями, так что в этой книге обе версии я называю как С++98. Говоря о С++11, я подразумеваю и С++11, и С++14, поскольку С++ 14 является надмножеством С++11. Когда я пишу “С++14”, я имею в виду конкретно С++14. А если я просто упоминаю С++, я делаю утверждение, которое относится ко всем версиям языка.

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

Наиболее важной особенностью С++11, вероятно, является семантика перемещения, а основой семантики перемещения является отличие rvalue -выражений от lvaluе -выражений. Поэтому rvalue указывают объекты, которые могут быть перемещены, в то время как lvalue в общем случае перемещены быть не могут. Концептуально (хотя и не всегда на практике), rvalue соответствуют временным объектам, возвращаемым из функций, в то время как lvalue соответствуют объектам, на которые вы можете ссылаться по имени, следуя указателю или lvalue-ссылке.

Полезной эвристикой для выяснения, является ли выражение lvalue, является ответ на вопрос, можно ли получить его адрес. Если можно, то обычно это lvalue. Если нет, это обычно rvalue. Приятной особенностью этой эвристики является то, что она помогает помнить, что тип выражения не зависит от того, является ли оно lvalue или rvalue. Иначе говоря, для данного типа Тможно иметь как lvalue типа Т, так и rvalue типа Т. Особенно важно помнить это, когда мы имеем дело с параметром rvalue ссылочного типа, поскольку сам по себе параметр является lvalue:

class Widget {

public:

Widget( Widget&& rhs); // rhs является lvalue , хотя

// и имеет ссылочный тип rvalue

};

Здесь совершенно корректным является взятие адреса rhsв перемещающем конструкторе Widget, так что rhsпредставляет собой lvalue, несмотря на то что его тип — ссылка rvalue. (По сходным причинам все параметры являются lvalue.)

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

• Имя класса — Widget. Я использую слово Widget, когда хочу сослаться на произвольный пользовательский тип. Если только мне не надо показать конкретные детали класса, я использую имя Widget, не объявляя его.

• Я использую имя параметра rhs(“right-hand side”, правая сторона). Это предпочитаемое мною имя параметра для операций перемещения (например, перемещающего конструктора и оператора перемещающего присваивания) и операций копирования (например, копирующего конструктора и оператора копирующего присваивания). Я также использую его в качестве правого параметра бинарных операторов:

Matrix operator+(const Matrix& lhs, const Matrix& rhs);

Я надеюсь, для вас не станет сюрпризом, что lhs означает “left-hand side” (левая сторона).

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

• Я использую “ …”, чтобы указать “здесь находится прочий код”. Такое “узкое” троеточие отличается от широкого “ ...”, используемого в исходных текстах шаблонов с переменным количеством параметров в С++11. Это кажется запутанным, но на самом деле это не так. Вот пример.

template // Эти троеточия

void processVals(const Ts&... params) // в исходном

{ // тексте С++

… // Это троеточие озна-

// чает какой-то код

}

Объявление processValsпоказывает, что я использую ключевое слово typenameпри объявлении параметров типов в шаблонах, но это просто мое личное предпочтение; вместо него можно использовать ключевое слово class. В тех случаях, когда я показываю код, взятый из стандарта С++, я объявляю параметры типа с использованием ключевого слова class, поскольку так делает стандарт.

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