Стенли Липпман - Язык программирования C++. Пятое издание

• Название: Язык программирования C++. Пятое издание
• Автор: Стенли Липпман
• Издательство: Издательский дом "Вильямс"
• Жанр: Программирование
• Год: 2014
• ISBN: 978-5-8459-1839-0

Лучшее руководство по программированию и справочник по языку, полностью пересмотренное и обновленное под стандарт С++11!

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

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

Стенли Б. Липпман работал старшим консультантом в Jet Propulsion Laboratory, архитектором группы Visual С++ корпорации Microsoft, техническим сотрудником Bell Laboratories и главным инженером- программистом по анимации в кинокомпаниях Disney, DreamWorks, Pixar и PDI.

Жози Лажойе, работающий ныне в кинокомпании Pixar, был членом канадской группы разработчиков компилятора C/C++ корпорации IBM, а также возглавлял рабочую группу базового языка С++ в составе международной организации по стандартизации ANSI/ISO.

Барбара Э. Му имеет почти тридцатилетний опыт программирования. На протяжении пятнадцати лет она работала в компании AT&T, сотрудничая с Бьярне Страуструпом, автором языка С++, и несколько лет руководила группой разработчиков С++.

• Узнайте, как использовать новые средства языка С++11 и стандартной библиотеки для быстрого создания надежных программ, а также ознакомьтесь с высокоуровневым программированием

• Учитесь на примерах, в которых показаны передовые стили программирования и методики проектирования

• Изучите принципы и узнайте почему язык С++11 работает именно так

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

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

• Освойте лучшие методики программирования и закрепите на практике изученный материал

Исходный код примеров можно загрузить с веб-страницы книги на сайте издательства по адресу: http://www.williamspublishing.com

---

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

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

Рассмотрим самый простой случай. Предположим, что в глобальной области видимости определено пространство имен А и функция f(). Если функция f() имеет директиву using для пространства имен А, функция f() будет вести себя так, как будто имена пространства имен А присутствовали в глобальной области видимости до определения функции f().

// пространство имен А и функция f() определены в глобальной области

// видимости

namespace А {

 int i, j;

}

void f() {

 using namespace A; // переводит имена из области видимости А в

                    // глобальную область видимости

 cout << i * j << endl; // использует i и j из пространства имен A

 // ...

}

Пример директив using

Рассмотрим следующий пример:

namespace blip {

 int i = 16, j = 15, k = 23; // другие объявления

}

int j = 0; // ok: j в пространстве имен blip скрыта

void manip() {

 // директива using; имена пространства имен blip "добавляются" к

 // глобальной области видимости

 using namespace blip; // конфликт между ::j и blip::j

 // обнаруживается только при использовании j

 ++i;        // присваивает blip::i значение 17

 ++j;        // ошибка неоднозначности: global j или blip::j?

 ++::j;      // ok: присваивает глобальной j значение 1

 ++blip::j;  // ok: присваивает blip::j значение 16

 int k = 97; // локальная k скрывает blip::k

 ++k;        // присваивает локальной k значение 98

}

Директива using в функции manip() делает все имена пространства имен blip доступными непосредственно. То есть функция manip() может обращаться к этим членам, используя краткую форму имен.

Члены пространства имен blip выглядят так, как будто они были определены в одной области видимости. Если пространство имен blip определено в глобальной области видимости, его члены будут выглядеть так, как будто они объявлены в глобальной области видимости.

Когда пространство имен вводится в окружающую область видимости, имена в пространстве имен вполне могут вступить в конфликт с другими именами, определенными (включенными) в той же области видимости. Например, в функции manip() член j пространства имен blip вступает в конфликт с глобальным объектом j. Такие конфликты разрешимы, но для использования имени следует явно указать, какая версия имеется в виду. Любое использование имени j в пределах функции manip() ведет к неоднозначности.

Чтобы использовать такое имя, как j, следует применить оператор области видимости, позволяющий указать требуемое имя. Для указания переменной j, определенной в глобальной области видимости, нужно написать ::j, а для определенной в пространстве имен blip — blip::j.

Поскольку имена находятся в разных областях видимости, локальные объявления в пределах функции manip() могут скрыть некоторые из имен пространства имен. Локальная переменная k скрывает член пространства имен blip::k. Обращение к переменной k в пределах функции manip() вполне однозначно, это обращение к локальной переменной k.

Заголовки и объявления using или директивы

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

Внимание! Избегайте директив using

Директивы using, вводящие в область видимости все имена из пространства имен, обманчиво просты в использовании. Единственный оператор делает видимыми имена всех членов пространства имен. Хоть этот подход может показаться простым, он создает немало проблем. Если в приложении использовано много библиотек и директива using сделает видимыми имена, определенные в них, то вновь возникнет проблема загромождения глобального пространства имен.

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

Еще одна вызванная директивой using проблема неоднозначности обнаруживается только в момент применения. Столь позднее обнаружение означает, что конфликты могут возникать значительно позже применения определенной библиотеки. То есть при использовании в программе новой библиотеки могут возникнуть не обнаруженные ранее конфликты.

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

Директивы using на самом деле полезны в файлах реализации самого пространства имен.

Упражнения раздела 18.2.2

Упражнение 18.15. Объясните различия между объявлением и директивой using.

Упражнение 18.16. Объясните следующий код с учетом того, что объявления using для всех членов пространства имен Exercise находятся в области, помеченной как позиция 1. Что, если вместо этого они располагаются в позиции 2? Теперь ответьте на тот же вопрос, но замените объявления using директивой using для пространства имен Exercise.

namespace Exercise {

 int ivar = 0;

 double dvar = 0;

 const int limit = 1000;

}

int ivar = 0;

// позиция 1

void manip() {

 // позиция 2

 double dvar = 3.1416;

 int iobj = limit + 1;

 ++ivar;

 ++::ivar;

}

Упражнение 18.17. Напишите код для проверки ответов на предыдущий вопрос.

18.2.3. Классы, пространства имен и области видимости

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

namespace A {

 int i;

 namespace В {

  int i; // скрывает A::i в В

  int j;

  int f1() {

   int j;    // j локальна для f1() и скрывает A::B::j

   return i; // возвращает B::i

  }

 } // пространство имен В закрыто, и его имена больше не видимы

 int f2() {

  return j; // ошибка: j не определена

 }

 int j = i; // инициализируется значением A::i

}

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