Стенли Липпман - Язык программирования 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

---

• Как только имя mem будет найдено, осуществляется обычная проверка соответствия типов (см. раздел 6.1), гарантирующая допустимость найденного определения для данного вызова.

• Если вызов допустим, компилятор создает код, зависящий от того, является ли вызываемая функция виртуальной или нет:

  - Если функция mem() виртуальная и вызов осуществляется через ссылку или указатель, то компилятор создает код, который во время выполнения определяет на основании динамического типа объекта выполняемую версию функции.

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

Как обычно, поиск имени осуществляется перед проверкой соответствия типов

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

struct Base {

 int memfcn();

};

struct Derived : Base {

 int memfcn(int); // скрывает memfcn() в базовом классе

};

Derived d; Base b;

b.memfcn();       // вызов Base::memfcn()

d.memfcn(10);     // вызов Derived::memfcn()

d.memfcn();       // ошибка: memfcn() без аргументов скрывается

d.Base::memfcn(); // ok: вызов Base::memfcn()

Объявление функции memfcn() в классе Derived скрывает объявление функции memfcn() в классе Base. Не удивительно, что первый вызов через объект b класса Base вызывает версию в базовом классе. Точно так же второй вызов (через объект d) вызывает версию класса Derived. Удивительно то, что третий вызов, d.memfcn(), некорректен.

Чтобы распознать этот вызов, компилятор ищет имя memfcn в классе Derived. Этот класс определяет член по имени memfcn, и поиск на этом останавливается. Как только имя будет найдено, компилятор далее не ищет. Версия функции memfcn() в классе Derived ожидает аргумент типа int. Поскольку данный вызов такого аргумента не предоставляет, вызов ошибочен.

Виртуальные функции и область видимости

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

class Base {

public:

 virtual int fcn();

};

class D1 : public Base {

public:

 // скрывает fcn() в базовом; функция fcn() не виртуальна

 // D1 наследует определение из Base::fcn()

 int fcn(int);      // список параметров fcn() в Base другой

 virtual void f2(); // новая виртуальная функция,

                    // не существующая в Base

};

class D2 : public D1 {

public:

 int fcn(int); // невиртуальная функция скрывает D1::fcn(int)

 int fcn();    // переопределяет виртуальную функцию fcn() из Base

 void f2();    // переопределяет виртуальную функцию f2() из D1

};

Функция fcn() в классе D1 не переопределяет виртуальную функцию fcn() из класса Base, поскольку у них разные списки параметров. Вместо этого она скрывает функцию fcn() из базового класса. Фактически у класса D1 есть две функции по имени fcn(): класс D1 унаследовал виртуальную функцию fcn() от класса Base, а также определяет собственную невиртуальную функцию-член по имени fcn(), получающую параметр типа int.

Вызов скрытой виртуальной функции через базовый класс

С учетом классов, описанных выше, рассмотрим несколько разных способов вызова этих функций:

Base bobj; D1 d1obj; D2 d2obj;

Base *bp1 = &bobj, *bp2 = &d1obj, *bp3 = &d2obj;

bp1->fcn(); // виртуальный вызов Base::fcn() во время выполнения

bp2->fcn(); // виртуальный вызов Base::fcn() во время выполнения

bp3->fcn(); // виртуальный вызов D2::fcn() во время выполнения

D1 *d1p = &d1obj; D2 *d2p = &d2obj;

bp2->f2(); // ошибка: Base не имеет члена по имени f2()

d1p->f2(); // виртуальный вызов D1::f2() во время выполнения

d2p->f2(); // виртуальный вызов D2::f2() во время выполнения

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

Это решение будет принято на основании фактического типа объекта, с которым связан указатель. В случае указателя bp2 основной объект имеет тип D1. Этот класс не переопределит функцию fcn() без параметров. Таким образом, вызов через указатель bp2 распознается (во время выполнения) как версия, определенная в классе Base.

Следующие три вызова осуществляются через указатели с отличными типами. Каждый указатель указывает на один из типов в этой иерархии. Первый вызов некорректен, так как в классе Base нет функции f2(). Тот факт, что указатель случайно указывает на производный объект, является несущественным.

И наконец, рассмотрим вызовы невиртуальной функции fcn(int):

Base *p1 = &d2obj; D1 *p2 = &d2obj; D2 *p3 = &d2obj;

p1->fcn(42); // ошибка: Base не имеет версии fcn(), получающей int

p2->fcn(42); // статическое связывание, вызов D1::fcn(int)

p3->fcn(42); // статическое связывание, вызов D2::fcn(int)

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

Переопределение перегруженных функций

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

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

Вместо переопределения каждой версии базового класса, которую он унаследовал, производный класс может предоставить объявление using (см. раздел 15.5) для перегруженного члена. Объявление using определяет только имя; оно не может определить список параметров. Таким образом, объявление using для функции-члена базового класса добавляет все перегруженные экземпляры этой функции в область видимости производного класса. Перенеся все имена в свою область видимости, производный класс должен определить только те функции, которые действительно зависят от его типа.

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

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

Упражнение 15.23. Предположим, что класс D1 намеревается переопределить свою унаследованную функцию fcn(). Как исправить этот класс? Предположим, что класс исправлен так, что функция fcn() соответствует определению в классе Base. Как бы распознавались вызовы в этом разделе?

15.7. Конструкторы и функции управления копированием

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