Назовите те части программы, которые находятся в области видимости класса и для которых при разрешении имен просматривается полная область (т.е. принимаются во внимание все члены, объявленные в теле класса).
Упражнение 13.20
К каким объявлениям относится имя Type при использовании в теле класса Exersise и в определении его функции-члена setVal()? (Напоминаем, что разные вхождения могут относиться к разным объявлениям.) К каким объявлениям относится имя initVal при
typedef int Type; Type initVal();
class Exercise { public:
// ...
typedef double Type; Type setVal( Type ); Type initVal();
private: int val;
};
Type Exercise::setVal( Type parm )
{
val = parm + initVal();
употреблении в определении функции-члена setVal()?
}
Определение функции-члена setVal() ошибочно. Можете ли вы сказать, почему? Внесите необходимые изменения, чтобы в классе Exercise использовался глобальный typedef Type и глобальная функция initVal().
13.10. Вложенные классы A
Класс, объявленный внутри другого класса, называется вложенным. Он является членом объемлющего класса, а его определение может находиться в любой из секций public, private или protected объемлющего класса.
Имя вложенного класса известно в области видимости объемлющего класса, но ни в каких других областях. Это означает, что оно не конфликтует с таким же именем, объявленным в объемлющей области видимости. Например:
class Node { /* ... */ }
class Tree { public:
//Node инкапсулирован внутри области видимости класса Tree
//В этой области Tree::Node скрывает ::Node
class Node {...};
// правильно: разрешается в пользу вложенного класса: Tree::Node
Node *tree;
};
//Tree::Node невидима в глобальной области видимости
//Node разрешается в пользу глобального объявления Node Node *pnode;
class List { public:
//Node инкапсулирован внутри области видимости класса List
//В этой области List::Node скрывает ::Node
class Node {...};
// правильно: разрешается в пользу вложенного класса: List::Node
Node *list;
};
// Не идеально, будем улучшать |
|
class List { |
|
public: |
|
class ListItem { |
// объявление друга |
friend class List; |
|
ListItem( int val=0 ); |
// конструктор |
ListItem *next; |
// указатель на собственный |
класс |
|
int value; |
|
}; // ...
private:
ListItem *list; ListItem *at_end;
Для вложенного класса допустимы такие же виды членов, как и для невложенного:
};
Закрытым называется член, который доступен только в определениях членов и друзей класса. У объемлющего класса нет права доступа к закрытым членам вложенного. Чтобы в определениях членов List можно было обращаться к закрытым членам ListItem, класс ListItem объявляет List как друга. Равно и вложенный класс не имеет никаких специальных прав доступа к закрытым членам объемлющего класса. Если бы нужно было разрешить ListItem доступ к закрытым членам класса List, то в объемлющем классе List следовало бы объявить вложенный класс как друга. В приведенном выше примере этого не сделано, поэтому ListItem не может обращаться к закрытым членам
List.
Объявление ListItem открытым членом класса List означает, что вложенный класс можно использовать как тип во всей программе, в том числе и за пределами определений
// правильно: объявление в глобальной области видимости
членов и друзей класса. Например:
List::ListItem *headptr;
Это дает более широкую область видимости, чем мы планировали. Вложенный ListItem поддерживает абстракцию класса List и не должен быть доступен во всей программе.
// Не идеально, будем улучшать
class List { public:
// ...
private:
class ListItem { // ...
};
ListItem *list; ListItem *at_end;
Поэтому лучше объявить вложенный класс ListItem закрытым членом List:
};
Теперь тип ListItem доступен только из определений членов и друзей класса List, поэтому все члены класса ListItem можно сделать открытыми. При таком подходе объявление List как друга ListItem становится ненужным. Вот новое определение
// так лучше class List { public:
//...
private:
//Теперь ListItem закрытый вложенный
тип class ListItem {
// а его члены открыты public:
ListItem( int val=0 ); ListItem *next;
int value;
};
ListItem *list; ListItem *at_end;
класса List:
};
Конструктор ListItem не задан как встроенный внутри определения класса и, следовательно, должен быть определен вне него. Но где именно? Конструктор класса ListItem не является членом List и, значит, не может быть определен в теле последнего; его нужно определить в глобальной области видимости – той, которая
содержащий интерфейс List. Таким образом, определение ListItem может находиться лишь внутри исходного файла, включающего реализацию класса List и его членов.
Вложенный класс можно сначала объявить, а затем определить в теле объемлющего. Это
class List { public:
//...
private:
//объявление List::ListItem class ListItem;
class Ref {
// pli имеет тип List::ListItem*
ListItem *pli;
};
определение List::ListItem class ListItem {
// pref имеет тип List::Ref* Ref *pref;
};
позволяет иметь во вложенных классах члены, ссылающиеся друг на друга:
};
Если бы ListItem не был объявлен перед определением класса Ref, то объявление члена pli было бы ошибкой.
Вложенный класс не может напрямую обращаться к нестатическим членам объемлющего, даже если они открыты. Любое такое обращение должно производиться
class List { public:
int init( int ); private:
class List::ListItem { public:
ListItem( int val=0 ); void mf( const List & ); int value;
};
};
List::ListItem::ListItem { int val )
{
//List::init() - нестатический член класса List
//должен использоваться через объект или указатель на тип List
value = init( val ); // ошибка: неверное использование init
через указатель, ссылку или объект объемлющего класса. Например:
};
При использовании нестатических членов класса компилятор должен иметь возможность идентифицировать объект, которому принадлежит такой член. Внутри функции-члена класса ListItem указатель this неявно применяется лишь к его членам. Благодаря неявному this мы знаем, что член value относится к объекту, для которого вызван конструктор. Внутри конструктора ListItem указатель this имеет тип ListItem*. Для доступа же к функции-члену init() нужен объект типа List или указатель типа List*.
