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'у

является недопустимым. Для того, чтобы это преодолеть, можно воспользоваться конструкторами:

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, когда сначала

присваивается значение одного типа, а потом рассматривается как другой тип. Эта проблема решается встраиванием объединния в класс, который отслеживает, какого типа значение помщается:

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 amp; ival (* check('I',"ival"); return i; *) double amp; fval (* check('D',"fval"); return d; *) char* amp; 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 не пройдет *)

Если у класса есть конструктор, то он вызывается всегда, когда создается объект класса. Если у класса есть деструктор, то он вызывается всегда, когда объект класса уничтожается. Объекты могут создаваться как:

1. Автоматический объект: создается каждый раз, когда его описание встречается при выполнении программы, и уничтжается каждый раз при выходе из блока, в котором оно появлось;

2. Статический объект: создается один раз, при запуске программы, и уничтожается один раз, при ее завершении;

3. Объект в свободной памяти: создается с помощью опрации new и уничтожается с помощью операции delete;

4. Объект член: как объект другого класса или как элмент вектора.

Объект также может быть построен с помощью явного примнения конструктора в выражении (см. #6.4), в этом случае он является автоматическим объектом. В следующих подразделах предполагается, что объекты принадлежат классу, имеющему конструктор и деструктор. Примером может служить класс table из #5.3.

Если 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; *) *);