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

14.3.2. Вывод классов и определение виртуальных функций

Мы указываем, что класс является производным, упоминая базовый класс перед его именем. Рассмотрим пример.

struct Circle:Shape { /* ... */ }; 

 

 По умолчанию члены структуры, объявляемой с помощью ключевого слова struct, являются открытыми (см. раздел 9.3) и наследуют открытые члены класса. Можно было бы написать эквивалентный код следующим образом:

class Circle : public Shape { public: /* ... */ };

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

Не забудьте указать слово public, когда захотите объявить открытые члены класса. Рассмотрим пример.

class Circle : Shape { public: /* ... */ }; // возможно, ошибка

В этом случае класс Shape считается закрытым базовым классом для класса Circle, а открытые функции-члены класса Shape становятся недоступными для класса Circle. Вряд ли вы стремились к этому. Хороший компилятор предупредит вас о возможной ошибке. Закрытые базовые классы используются, но их описание выходит за рамки нашей книги.

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

struct Shape {

  // ...

  virtual void draw_lines() const;

  virtual void move();

  // ...

};

  virtual void Shape::draw_lines() const { /* ... */ } // ошибка

  void Shape::move() { /* ... */ } // OK

14.3.3. Замещение

 

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

struct Circle:Shape {

  void draw_lines(int) const; // возможно, ошибка (аргумент int?)

  void drawlines() const;     // возможно, ошибка (опечатка в имени?)

  void draw_lines();          // возможно, ошибка (нет const?)

  // ...

};

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

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

struct B {

  virtual void f() const { cout << "B::f "; }

  void g() const { cout << "B::g "; } // невиртуальная

};

struct D : B {

  void f() const { cout << "D::f "; } // замещает функцию B::f

  void g() { cout << "D::g "; }

};

struct DD : D {

  void f() { cout << "DD::f "; } // не замещает функцию D::f (нет const)

  void g() const { cout << "DD::g "; }

};

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

void call(const B& b)

  // класс D — разновидность класса B,

  // поэтому функция call() может

  // получить объект класса D

  // класс DD — разновидность класса D,

  // а класс D — разновидность класса B,

  // поэтому функция call() может получать объект класса DD

{

  b.f();

  b.g();

}

int main()

{

  B b;

  D d;

  DD dd;

  call(b);

  call(d);

  call(dd);

  b.f();

  b.g();

  d.f();

  d.g();

  dd.f();

  dd.g();

}

В результате выполнения этой программы получим следующее:

B::f B::g D::f B::g D::f B::g B::f B::g D::f D::g DD::f DD::g

Если вы понимаете, почему, то знаете механизмы наследования и виртуальных функций. 

14.3.4. Доступ

 

 Язык С++ реализует простую модель доступа к членам класса. Члены класса могут относиться к следующим категориям.

• Закрытые (private). Если член класса объявлен с помощью ключевого слова private, то его имя могут использовать только члены данного класса.

• Защищенные (protected). Если член класса объявлен с помощью ключевого слова protected, то его имя могут использовать только члены данного класса или члены классов, производных от него.

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

Изобразим это на рисунке.

Базовый класс также может иметь атрибут private, protected или public.

• Если базовый класс для класса D является закрытым, то имена его открытых и защищенных членов могут использоваться только членами класса D. 

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