описании трудно разобраться. Кроме того, вложение классов - это не
более чем соглашение о записи, поскольку вложенный класс не
является скрытым в области видимости лексически охватывающего
класса:
class set {
struct setmem {
int mem;
setmem* next;
setmem(int m, setmem* n)
};
// ...
};
setmem::setmem(int m, setmem* n) { mem=m, next=n}
setmem m1(1,0);
Такая запись, как set::setmem::setmem(), не является ни
необходимой, ни допустимой. Единственный способ скрыть имя класса -
это сделать это с помощью метода файлы-как-модули (#4.4). Большую
часть нетривиальных классов лучше описывать раздельно:
- стр 160 -
class setmem {
friend class set; // доступ только с помощью членов set
int mem;
setmem* next;
setmem(int m, setmem* n) { mem=m; next=n; }
};
class set {
setmem* first;
public:
set() { first=0; }
insert(int m) { first = new setmem(m,first);}
// ...
};
5.4.4 Статические Члены
Класс - это тип, а не объект данных, и в каждом объекте класса
имеется своя собственная копия данных, членов этого класса. Однако
некоторые типы наиболее элегантно реализуются, если все объекты
этого типа могут совместно использовать (разделять) некоторые
данные. Предпочтительно, чтобы такие разделяемые данные были
описаны как часть класса. Например, для управления задачами в
операционной системе или в ее модели часто бывает полезен список
всех задач:
class task {
// ...
task* next;
static task* task_chain;
void shedule(int);
void wait(event);
// ...
};
Описание члена task_chain (цепочка задач) как static обеспечивает,
что он будет всего лишь один, а не по одной копии на каждый объект
task. Он все равно остается в области видимости класса task, и
"извне" доступ к нему можно получить, только если он был описан как
public. В этом случае его имя должно уточняться именем его класса:
task::task_chain
В функции члене на него можно ссылаться просто task_chain.
Использование статических членов класса может заметно снизить
потребность в глобальных переменных.
5.4.5 Указатели на Члены
Можно брать адрес члена класса. Получение адреса функции члена
часто бывает полезно, поскольку те цели и причины, которые
приводились в #4.6.9 относительно указателей на функции, в равной
степени применимы и к функциям членам. Однако, на настоящее время в
- стр 161 -
языке имеется дефект: невозможно описать выражением тип указателя,
который получается в результате этой операции. Поэтому в текущей
реализации приходится жульничать, используя трюки. Что касается
примера, который приводится ниже, то не гарантируется, что он будет
работать. Используемый трюк надо локализовать, чтобы программу
можно было преобразовать с использованием соответствующей языковой
конструкции, когда появится такая возможнось. Этот трюк использует
тот факт, что в текущей реализации this реализуется как первый
(скрытый) параметр функции члена:
#include
struct cl
{
char* val;
void print(int x) { cout << val << x << "\n"; };
cl(char* v) { val = v; }
};
// ``фальшивый'' тип для функций членов:
typedef void (*PROC)(void*, int);
main()
{
cl z1("z1 ");
cl z2("z2 ");
PROC pf1 = PROC(&z1.print);
PROC pf2 = PROC(&z2.print);
z1.print(1);
(*pf1)(&z1,2);
z2.print(3);
(*pf2)(&z2,4);
}
Во многих случаях можно воспользоваться виртуальными функциями
(см. Главу 7) там, где иначе пришлось бы использовать указатели на
функции*.
____________________
* Более поздние версии C++ поддерживают понятие указатель на
член: cl::* означает "указатель на член класса cl". Например:
typedef void (cl::*PROC)(int);
PROC pf1 = &cl::print; // приведение к типу ненужно
PROC pf2 = &cl::print;
Для вызовов через указатель на функцию член используются операции .
и ->. Например:
(z1.*pf1)(2);
((&z2)->*pf2)(4);
(прим. автора)
- стр 162 -
5.4.6 Структуры и Объединения
По определению struct - это просто класс, все члены которого
общие, то есть
struct s { ...
есть просто сокращенная запись
class s { public: ...
Структуры используются в тех случаях, когда скрытие данных
неуместно.
Именованное объединение определяется как struct, в которой все
члены имеют один и тот же адрес (см. #с.8.5.13). Если известно, что
в каждый момент времени нужно только одно значение из структуры, то
объединение может сэкономить пространство. Например, можно
определить объединение для хранения лексических символов C
компилятора:
union tok_val {
char* p; // строка
char v[8]; // идентификатор (максимум 8 char)
long i; // целые значения
double d; // значения с плавающей точкой
};
Сложность состоит в том, что компилятор, вообще говоря, не знает,
какой член используется в каждый данный момент, поэтому надлежащая
проверка типа невозможна. Например:
void strange(int i)
{
tok_val x;
if (i)
x.p = "2";
else
x.d = 2;
sqrt(x.d); // ошибка если i != 0
}
Кроме того, объединение, определенное так, как это, нельзя
инициализировать. Например:
tok_val curr_val = 12; // ошибка: int присваивается tok_val'у
является недопустимым. Для того, чтобы это преодолеть, можно
воспользоваться конструкторами:
- стр 163 -
union tok_val {
char* p; // строка
char v[8]; // идентификатор (максимум 8 char)
long i; // целые значения
double d; // значения с плавающей точкой
tok_val(char*); // должна выбрать между p и v
tok_val(int ii) { i = ii; }
tok_val() { d = dd; }
};
Это прозволяет справляться с теми ситуациями, когда типы членов
могут быть разрешены по правилам для перегрузки имени функции (см.
#4.6.7 и #6.3.3). Например:
void f()
{
tok_val a = 10; // a.i = 10
tok_val b = 10.0; // b.d = 10.0
}
Когда это невозможно (для таких типов, как char* и char[8], int и
char, и т.п.), нужный член может быть найден только посредством
анализа инициализатора в ходе выполнения или с помощью задания
дополнительного параметра. Например:
tok_val::tok_val(char* pp)
{
if (strlen(pp) <= 8)
strncpy(v,pp,8); // короткая строка
else
p = pp; // длинная строка
}
Таких ситуаций вообще-то лучше избегать.
Использование конструкторов не предохраняет от такого случайного
неправильного употребления tok_val, когда сначала присваивается
значение одного типа, а потом рассматривается как другой тип. Эта
проблема решается встраиванием объединения в класс, который
отслеживает, какого типа значение помещается:
- стр 164 -
class tok_val {
char tag;
union {
char* p;
char v[8];
long i;
double d;
};
int check(char t, char* s)
{ if (tag!=t) { error(s); return 0; } return 1; }
public:
tok_val(char* pp);
tok_val(long ii) { i=ii; tag='I'; }
tok_val(double dd) { d=dd; tag='D'; }
long& ival() { check('I',"ival"); return i; }
double& fval() { check('D',"fval"); return d; }
char*& sval() { check('S',"sval"); return p; }
char* id() { check('N',"id"); return v; }
};
Конструктор, получающий строковый параметр, использует для
копирования коротких строк strncpy(). strncpy() похожа на strcpy(),
но получает третий параметр, который указывает, сколько символов
должно копироваться:
tok_val::tok_val(char* pp)
{
if (strlen(pp) <= 8) { // короткая строка
tag = 'N'
strncpy(v,pp,8); // скопировать 8 символов
}
else { // длинная строка
tag = 'S'
p = pp; // просто сохранить указатель
}
}
Тип tok_val можно использовать так:
void f()
{
tok_val t1("short"); // короткая, присвоить v
tok_val t2("long string"); // длинная строка, присвоить p
char s[8];
strncpy(s,t1.id(),8); // ok
strncpy(s,t2.id(),8); // проверка check() не пройдет
}
5.5 Конструкторы и Деструкторы
Если у класса есть конструктор, то он вызывается всегда, когда
создается объект класса. Если у класса есть деструктор, то он
- стр 165 -
вызывается всегда, когда объект класса уничтожается. Объекты могут
создаваться как:
[1] Автоматический объект: создается каждый раз, когда его
описание встречается при выполнении программы, и уничтожается
каждый раз при выходе из блока, в котором оно появилось;
[2] Статический объект: создается один раз, при запуске
программы, и уничтожается один раз, при ее завершении;
[3] Объект в свободной памяти: создается с помощью операции new
и уничтожается с помощью операции delete;
[4] Объект член: как объект другого класса или как элемент
вектора.
Объект также может быть сконструирован с помощью явного примения
конструктора в выражении (см. #6.4), в этом случае он является
автоматическим объектом. В следующих подразделах предполагается,
что объекты принадлежат классу, имеющему конструктор и деструктор.
Примером может служит класс table из #5.3.
5.5.1 Предостережение
Если x и y - объекты класса cl, то x=y в стандартном случае
означает побитовое копирование y в x (см. #2.3.8). Такая
интерпретация присваивания может привести к изумляющему (и обычно
нежелательному) результату, если оно применяется к объектам класса,
для которого определены конструктор и деструктор. Например:
class char_stack {
int size;
char* top;
char* s;
public:
char_stack(int sz) { top=s=new char[size=sz]; }
~char_stack() { delete s; } // деструктор
void push(char c) { *top++ = c; }
char pop() { return *--top; }
};
void h()
{
char_stack s1(100);
char_stack s2 = s1; // неприятность
char_stack s3(99);
s3 = s2; // неприятность
}
Здесь конструктор char_stack::char_stack() вызывается дважды: для
s1 и для s3. Для s2 он не вызывается, поскольку эта переменная
инициализируется присваиванием. Однако деструктор
char_stack::~char_stack() вызывается трижды: для s1, s2 и s3! Кроме
того, по умолчанию действует интерпретация присваивания как
побитовое копирование, поэтому в конце h() каждый из s1, s2 и s3
будет содержать указатель на вектор символов, размещенный в
свободной памяти при создании s1. Не останется никакого указателя
на вектор символов, выделенный при создании s3. Таких отклонений
можно избежать: см. Главу 6.
- стр 166 -
5.5.2 Статическая Память
Рассмотрим следующее:
table tbl1(100);
void f() {
static table tbl2(200);
}
main()
{
f();
}
Здесь конструктор table::table(), определенный в #5.3.1, будет
вызываться дважды: один раз для tbl1 и один раз для tbl2.
Деструктор table::~table() также будет вызван дважды: для
уничтожения tbl1 и tbl2 после выхода из main(). Конструкторы для