Видимость
В C++ существует подробная (а по мнению некоторых, даже слишком подробная) система правил, по которым можно узнать, что вы видите прямо перед собой, а что вышло из вашего поля зрения. Базовые правила для открытых защищенных и закрытых символических имен в классах и структурах настолько просты, что я не стану их пересказывать. Ниже приведена краткая сводка наиболее каверзных вопросов, относящихся к понятию видимости (visibility) в C++.
Закрытое наследование
При закрытом наследовании от базового класса все его защищенные и открытые члены становятся закрытыми в производном классе; члены закрытого базового класса недоступны для пользователей производного класса. Доступ к ним возможен лишь из функций базового и производного класса, а также из друзей производного класса.
Кроме того, производный класс нельзя преобразовать к одному из его закрытых базовых классов или надеяться, что это сделает компилятор.
class Mixin {
private:
int x;
protected:
int y;
public:
Mixin();
Void a();
};
30
class Foo : private Mixin {...};
class Bar : public Foo {...};
Переменная х видна лишь в функциях класса Mixin - в конструкторе и А(). Переменная у видна лишь в функциях класса Foo, как и функция Mixin::A(). Все члены Mixin не видны в классах, производных от Foo (таких как Ваr в этом фрагменте). Все друзья Foo видят х и А(), а друзья Bar - нет.
Переобъявление членов
Хотя описанная ситуация возникает довольно редко, допускается переобъявление виртуальных функций с целью изменения их атрибутов видимости по отношению к базовому классу.
class Foo {
protected:
virtual void Fn();
};
class Bar : public Foo {
public:
virtual void Fn();
};
В классе Foo функция Fn() была защищенной, но в новом варианте она объявлена открытой. Для переменных класса или невиртуальных функции это сделать нельзя. Переобъявление переменной или невиртуальной функции скрывает прототип из базового класса.
class Foo {
private:
int x;
public:
void Fn();
};
class Bar : public Foo {
private:
int x; // Вторая переменная с тем же именем
public:
void Fn(); // Вторая функция
};
// В клиентской программе
Bar *b = new Bar;
b->Fn(); // Вызывает Bar::Fn()
Foo* f = b; // Можно, потому что Foo - открытый базовый класс
f->Fn(); // Вызывает Foo::Fn()
Существуют две разные переменные с одним локальным именем х. В области действия Foo символическое имя х означает Foo::х. В области действия Bar символическое имя х означает Ваr::х.
Конечно, для открытой или защищенной переменной х это вызовет невероятную путаницу, но для закрытой переменной подобной двусмысленности не будет. Пример Fn() показывает, какой хаос возникает при скрытии открытой или защищенной функции класса. При попытке скрыть открытую или защищенную функцию хороший компилятор C++ выдает предупреждение.
Видимость перегруженных и виртуальных функций класса Если в базовом классе функция объявлена невиртуальной, превращать ее в виртуальную в производном
классе не рекомендуется. Она поведет себя не так, как виртуальная функция, и безнадежно запутает читателей вашей программы. Но на ситуацию можно взглянуть и под другим углом. Удивительно, но факт - ключевое слово virtual обязано присутствовать только в базовом классе. Если оно пропущено в производном классе, компилятор должен интерпретировать версию функции в производном классе так, словно она и там была объявлена виртуальной. Я люблю называть подобную логику работы компилятора DWIMNIS: «Do what I mean, not what I say» («Делай то, что я подразумеваю, а не то, что я говорю»). Как правило, в C++ эта логика начисто отсутствует, поэтому ее редкие проявления (как в данном случае) смотрятся неестественно. В следующем примере для обоих указателей будет вызвана функция Bar::Fn():
class Foo {
public:
virtual void Fn();
};
class Bar {
public:
void Fn(); // Все равно считается виртуальной
};
Bar* b = new Bar;
b->Fn(); // Вызывает Bar::Fn()
Foo* f = b;
f->Fn(); // Также вызывает Bar::Fn()
Подобные ситуации нежелательны по двум причинам. Во-первых, компилятор может неправильно интерпретировать их, и тогда в последней строке будет вызвана функция Foo::Fn(). Во-вторых, ваши коллеги ни за что не разберутся, почему в одном месте функция Fn() виртуальная, а в другом - нет.
После бессонной ночи они могут устроить погром в конторе. Если в производном классе создается функция с тем же именем, но с другой сигнатурой, она скрывает все сигнатуры базового класса для данной функции, но только в области действия производного класса.
Понятно? Нет? Что ж, вы не одиноки.
class Foo {
public:
virtual void Fn();
virtual void Fn(char*);
};
class Bar {
public:
virtual void Fn(int); // Можно, но не желательно
};
Вероятно, многие новички-программисты допоздна засиживались на работе, пытаясь разобраться в происходящем. А происходит следующее:
• При попытке вызвать Fn() через Ваr* доступной будет лишь одна сигнатура, void Fn(int).
Обе версии базового класса скрыты и недоступны через Bar*.
• При преобразовании Bar* в Foo* становятся доступными обе сигнатуры, объявленные в Foo, но не сигнатура void Fn(int). Более того, это не переопределение, поскольку сигнатура Bar::Fn() отличается от версии базового класса. Другими словами, ключевое слово virtual никак не влияет на работу этого фрагмента.
Если вам когда-нибудь захочется сделать нечто похожее, встаньте с кресла, медленно прогуляйтесь вокруг дома, сделайте глубокий вдох, сядьте за компьютер и придумайте что-нибудь другое. Если уж перегружать, то перегружайте все сигнатуры функции. Никогда не перегружайте часть сигнатур и никогда не добавляйте новые сигнатуры в производный класс без переопределения всех сигнатур функции базового класса. Если это покажется слишком сложным, запомните хорошее правило: когда при чтении программы возникают вопросы, вероятно, ваше решение неудачное.
Друзья
Любой класс может объявить что-нибудь своим другом (friend). Друзья компилируются обычным образом, за исключением того, что все защищенные и закрытые члены дружественного класса видны так, словно друг является функцией этого класса. Друзьями можно объявлять функции - как глобальные, так и члены классов. Классы тоже могут объявляться друзьями других классов; в этом случае во всех функциях класса-друга «видны» все члены того класса, другом которого он является.
class Foo;
class BarBar {
public:
int Fn(Foo*);
};
class Foo {
friend void GlobalFn(); // Дружественные глобальные функции
friend class Bar; // Дружественный класс
friend int BarBar::Fn(Foo*); // Дружественная функция класса
friend class DoesNotExist; // См. Ниже
private:
int x;
struct ListNode {
ListNode* next;
void* datum;
ListNode() : next(NULL), datum(NULL) {}
} head;
protected:
int y;
public:
void G();
};
void GlobalFn()
{
Foo* f = new Foo;
f->x = 17; // Разрешается из-за дружеских отношений
}
class Bar {
private:
Foo* f;
public:
Bar() : f(new Foo) {}
void WalkList();
};
void Bar::WalkList()
{
Foo::ListNode* n = f->head.next;
for (; n != NULL; n = n->next)
cout << n->datum << endl;
}
int BarBar::Fn(Foo* f)
{
return f->x;
}
Друзей принято объявлять сначала, перед членами класса и перед ключевыми словами public, protected и private. Это объясняется тем, что на друзей не действуют обычные атрибуты видимости; нечто либо является другом, либо не является. Весь фрагмент программы после определения класса Foo вполне допустим. Друзья имеют доступ ко всем членам Foo, включая закрытые. В этом примере есть одна действительно интересная строка - та, в которой другом объявляется несуществующий класс DoesNotExist. Как ни странно, она не вызовет ни предупреждения, ни ошибки компилятора. Объявления друзей игнорируются на момент компиляции Foo. Они используются лишь тогда, когда будет компилироваться друг. Даже когда друга не существует, компилятор остается в счастливом неведении.