Язык программирования C++. Пятое издание - Стенли Липпман

Например, класс string определяет все пять функций-членов управления копированием, а также стандартный конструктор. Если объединение будет содержать строку и не определит ее собственный стандартный конструктор или одну из функций-членов управления копированием, то компилятор синтезирует эту недостающую функцию как удаленную. Если у класса будет член типа объединения, у которого есть удаленная функция-член управления копированием, то соответствующая функция (функции) управления копированием самого класса также будет удалена.

Использование класса для управления членами объединения

Из-за сложностей создания и удаления членов типа класса такие объединения обычно встраивают в другой классе. Таким образом, класс получает возможность управлять состоянием при передаче из и в элемент типа класса. В качестве примера добавим в объединение член класса string. Определим объединение как анонимное и сделаем его членом класса Token. Класс Token будет управлять членами объединения.

Для отслеживания вида значения хранимого объединением обычно определяют отдельный объект, дискриминант (discriminant). Дискриминант позволяет различать значения, которые может содержать объединение. Для синхронизации объединения и его дискриминанта сделаем дискриминант также членом класса Token. Для отслеживания состояния члена объединения класс определит член типа перечисления (см. раздел 19.3).

Единственными определяемыми классом функциями будут стандартный конструктор, функции-члены управления копированием и ряд операторов присвоения, способных присваивать значение одного из типов объединения члену другого:

class Token {

public:

 // функции управления копированием необходимы потому, что у класса

 // есть объединение с членом типа string

 // определение конструктора перемещения и оператора присваивания при

 // перемещении остается в качестве самостоятельного упражнения

 Token(): tok(INT), ival{0} { }

 Token(const Token &t): tok(t.tok) { copyUnion(t); }

 Token &operator=(const Token&);

 // если объединение содержит строку, ее придется удалять;

 // см. раздел 19.1.2

 ~Token() { if (tok == STR) sval.~string(); }

 // операторы присвоения для установки разных членов объединения

 Token &operator=(const std::string&);

 Token &operator=(char);

 Token &operator=(int);

 Token &operator=(double);

private:

 enum {INT, CHAR, DBL, STR} tok; // дискриминант

 union { // анонимное объединение

  char cval;

  int ival;

  double dval;

  std::string sval;

 }; // у каждого объекта класса Token есть безымянный член типа этого

    // безымянного объединения

 // проверить дискриминант и скопировать член объединения, как надо

 void copyUnion(const Token&);

};

Класс определяет вложенное, безымянное перечисление с не ограниченной областью видимости (см. раздел 19.3), используемое как тип члена tok. Член tok определен после закрывающей фигурной скобки и перед точкой с запятой, завершающей определение перечисления, которое определяет tok, как имеющий тип этого безымянного перечисления (см. раздел 2.6.1).

Член tok будет использован как дискриминант. Когда объединение содержит значение типа int, член tok будет содержать значение INT; если объединение содержит значение типа string, то член tok содержит значение STR и т.д.

Стандартный конструктор инициализирует дискриминант и член объединения как содержащие значение 0 типа int.

Поскольку объединение содержит член, класс которого обладает деструктором, следует определить собственный деструктор, чтобы (условно) удалять член типа string. В отличие от обычных членов типа класса, члены типа класса, являющиеся частью объединения, не удаляются автоматически. У деструктора нет никакого способа узнать, значение какого типа хранит объединение. Таким образом, он не может знать, какой из членов следует удалить.

Поэтому деструктор проверяет, не содержит ли удаляемый объект строку. Если это так, то деструктор явно вызывает деструктор класса string (см. раздел 19.1.2) для освобождения используемой памяти. Если объединение содержит значение любого из встроенных типов, то деструктор не делает ничего.

Управление дискриминанта и удаление строки

Операторы присвоения устанавливают значение переменной tok и присваивают соответствующий член объединения. Подобно деструктору, эти функции-члены должны условно удалять строку, прежде чем присваивать новое значение объединению:

Token &Token::operator=(int i) {

 if (tok == STR) sval.~string(); // если это строка, освободить ее

 ival = i;  // присвоить соответствующий член

 tok = INT; // обновить дискриминант

 return *this;

}

Если текущим значением объединения является строка, ее следует освободить прежде, чем присвоить объединению новое значение. Для этого используется деструктор класса string.

Как только член типа string освобождается, предоставленное значение присваивается члену, тип которого соответствует типу параметра оператора. В данном случае параметр имеет тип int, поэтому он присваивается ival. Затем обновляется дискриминант и осуществляется выход.

Операторы присвоения для типов double и char ведут себя, как и версия для типа int, их определение остается в качестве самостоятельного упражнения. Версия для типа string отличается от других, поскольку она должна управлять переходом от типа string и к нему:

Token &Token::operator=(const std::string &s) {

 if (tok == STR) // если строка уже содержится, просто присвоить новую

  sval = s;

 else

  new(&sval) string(s); // в противном случае создать строку

 tok = STR; // обновить дискриминант

 return *this;

}

В данном случае, если объединение уже содержит строку, можно использовать обычный оператор присвоения класса string, чтобы предоставить новое значение существующей строке. В противном случае не будет никакого объекта класса string для вызова его оператора присвоения. Вместо этого придется создать строку в памяти, которая содержит объединение. Для создания строки в области, где располагается sval, используется размещающий оператор new (см. раздел 19.1.2). Строка инициализируется копией строкового параметра, затем обновляется дискриминант и осуществляется выход.

Управление членами объединения, требующее управления копированием

Подобно специфическим для типа операторам присвоения, конструктор копий и операторы присвоения должны проверять дискриминант, чтобы знать, как копировать переданное значение. Для выполнения этих действий определим функцию-член copyUnion().

Когда происходит вызов функции copyUnion() из конструктора копий, член объединения будет инициализирован значением по умолчанию, означая, что будет инициализирован первый член объединения. Поскольку строка не является первым элементом, вполне очевидно, что объединение содержит не строку. Оператор присвоения должен учитывать возможность того, что объединение уже содержит строку. Отработаем этот случай непосредственно в операторе присвоения. Таким образом, если параметр функции copyUnion() содержит строку, она должна создать собственную строку:

void Token::copyUnion(const Token &t) {

 switch (t.tok) {

 case Token::INT: ival = t.ival; break;

 case Token::CHAR: cval = t.cval; break;

 case Token::DBL: dval = t.dval; break;

 // для копирования строки создать ее, используя размещающий

 // оператор new; см. раздел 19.1.2

 case Token::STR: new(&sval) string(t.sval); break;

 }

}

Для проверки дискриминанта эта функция использует оператор switch (см. раздел 5.3.2). Значения встроенных типов просто присваиваются соответствующему члену; если копируемый член имеет тип string, он создается.

Оператор присвоения должен отработать три возможности для члена типа string: левый и правый операнды являются строками; ни один из операндов не является строкой; один, но не оба операнда являются строкой:

Token &Token::operator=(const Token &t) {

 // если этот объект содержит строку, a t нет, прежнюю строку следует

 // освободить