Объект производного класса фактически построен из нескольких частей. Каждый базовый класс вносит свою долю в виде подобъекта, составленного из нестатических данных-членов этого класса. Объект производного класса построен из подобъектов, соответствующих каждому из его базовых, а также из части, включающей нестатические члены самого производного класса. Так, наш объект NameQuery состоит из подобъекта Query, содержащего члены _loc и _solution, и части, принадлежащей NameQuery, - она содержит только член _name.
Внутри производного класса к членам, унаследованным из базового, можно обращаться напрямую, как к его собственным. (Глубина цепочки наследования не увеличивает затраты времени и не лимитирует доступ к ним.) Например:
void
NameQuery::
display_partial_solution( ostream &os )
{
os _name
" is found in "
(_solution ? _solution-size() : 0)
" lines of text\n";
}
Это касается и доступа к унаследованным функциям-членам базового класса: мы вызываем их так, как если бы они были членами производного - либо через его объект:
NameQuery nq( "Frost" );
// вызывается NameQuery::eval()
nq.eval();
// вызывается Query::display()
nq.display();
либо непосредственно из тела другой (или той же самой) функции-члена:
void
NameQuery::
match_count()
{
if ( ! _solution )
// вызывается Query::_vec2set()
_solution = _vec2set( &_loc );
return _solution-size();
}
Однако прямой доступ из производного класса к членам базового запрещен, если имя последнего скрыто в производном классе:
class Diffident {
public: // ...
protected:
int _mumble;
// ...
};
class Shy : public Diffident {
public: // ...
protected:
// имя Diffident::_mumble скрыто
string _mumble;
// ...
};
В области видимости Shy употребление неквалифицированного имени _mumble разрешается в пользу члена _mumble класса Shy (объекта string), даже если такое использование в данном контексте недопустимо:
void
Shy::
turn_eyes_down()
{
// ...
_mumble = "excuse me"; // правильно
// ошибка: int Diffident::_mumble скрыто
_mumble = -1;
}
Некоторые компиляторы помечают это как ошибку типизации. Для доступа к члену базового класса, имя которого скрыто в производном, необходимо квалифицировать имя члена базового класса именем самого этого класса с помощью оператора разрешения области видимости. Так выглядит правильная реализация функции-члена turn_eyes_down():
void
Shy::
turn_eyes_down()
{
// ...
_mumble = "excuse me"; // правильно
// правильно: имя члена базового класса квалифицировано
Diffident::_mumble = -1;
}
Функции-члены базового и производного классов не составляют множество перегруженных функций:
class Diffident {
public:
void mumble( int softness );
// ...
};
class Shy : public Diffident {
public:
// скрывает видимость функции-члена Diffident::_mumble,
// а не перегружает ее
void mumble( string whatYaSay );
void print( int soft, string words );
// ...
};
Вызов функции-члена базового класса из производного в этом случае приводит к ошибке компиляции:
Shy simon;
// правильно: Shy::mumble( string )
simon.mumble( "pardon me" );
// ошибка: ожидался первый аргумент типа string
// Diffident::mumble( int ) невидима
simon.mumble( 2 );
Хотя к членам базового класса можно обращаться напрямую, они сохраняют область видимости класса, в котором определены. А чтобы функции перегружали друг друга, они должны находиться в одной и той же области видимости. Если бы это было не так, следующие два экземпляра невиртуальной функции-члена turn_aside()
class Diffident {
public:
void turn_aside( );
// ...
};
class Shy : public Diffident {
public:
// скрывает видимость
// Diffident::turn_aside()
void turn_aside();
// ...
};
