|
29
void Fn(int);
void Fn(long);
//
Можно, если типы long и int отличаются размером
int Fn(int);
// Нельзя – отличается только тип возвращаемого значения
int Fn(char*);
//
Можно, отличаются аргументы
void Fn(int, char*);
void Fn(char*, int);
// Можно, аргументы следуют в другом порядке
void Fn(char* s, int x, int y = 17); // Можно – три аргумента вместо двух
Fn(“hello”, 17);
// Ошибка – совпадают две сигнатуры
Пока аргументы отличаются, компилятор не жалуется на изменение возвращаемого типа.
Инициализация по умолчанию (такая как
у=17
) может присутствовать при объявлении функции, хотя
позднее она может стать причиной неоднозначности при вызове функции (как в последней строке
примера).
Константные функции
Константная функция, аргументы которой совпадают с аргументами неконстантной функции, тем не
менее считается другой функцией. Компилятор вызывает константную или неконстантную версию в
зависимости от типа переменной, указывающей или ссылающейся на объект.
class Foo {
public:
void
Fn();
void Fn() const;
// Другая функция!
};
Foo* f = new Foo;
f->Fn();
//
Вызывается неконстантная версия
const Foo* f1 = f;
f1->Fn(); //
Вызывается константная версия
Видимость
В 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
обязано присутствовать только в базовом классе. Если оно
Do'stlaringiz bilan baham: |
