Страница:
5.5.3 Свободная Память
Рассмотрим:
main() (* table* p = new table(100); table* q = new table(200); delete p; delete p; // возможно, ошибка *)
Конструктор table::table() будет вызван дважды, как и деструктор table::~table(). То, что С++ не дает никаких грантий, что для объекта, созданного с помощью new, когда-либо будет вызван деструктор, ничего не значит. В предыдущей прорамме q не уничтожается, а p уничтожается дважды! Программист может счесть это ошибкой, а может и не счесть, в зависимости от типа p и q. Обычно то, что объект не уничтожается, являеся не ошибкой, а просто лишней тратой памяти. Уничтожение p дважды будет, как правило, серьезной ошибкой. Обычно резултатом применения delete дважды к одному указателю приводит к бесконечному циклу в подпрограмме управления свободной пмятью, но определение языка не задает поведение в таком слчае, и оно зависит от реализации.
Пользователь может определить новую реализацию операций new и delete (см. #3.2.6). Можно также определить способ взимодействия конструктора или деструктора с операциями new и delete (см. #5.5.6)
main() (* table* p = new table(100); table* q = new table(200); delete p; delete p; // возможно, ошибка *)
Конструктор table::table() будет вызван дважды, как и деструктор table::~table(). То, что С++ не дает никаких грантий, что для объекта, созданного с помощью new, когда-либо будет вызван деструктор, ничего не значит. В предыдущей прорамме q не уничтожается, а p уничтожается дважды! Программист может счесть это ошибкой, а может и не счесть, в зависимости от типа p и q. Обычно то, что объект не уничтожается, являеся не ошибкой, а просто лишней тратой памяти. Уничтожение p дважды будет, как правило, серьезной ошибкой. Обычно резултатом применения delete дважды к одному указателю приводит к бесконечному циклу в подпрограмме управления свободной пмятью, но определение языка не задает поведение в таком слчае, и оно зависит от реализации.
Пользователь может определить новую реализацию операций new и delete (см. #3.2.6). Можно также определить способ взимодействия конструктора или деструктора с операциями new и delete (см. #5.5.6)
5.5.4 Объекты Класса как Члены
Рассмотрим
class classdef (* table members; int no_of_members; // ... classdef(int size); ~classdef(); *);
Очевидное намерение состоит в том, что classdef должен содержать таблицу длиной size из членов members, а сложность – в том, как сделать так, чтобы конструктор table::table() вызывался с параметром size. Это делается так:
classdef::classdef(int size) : members(size) (* no_of_members = size; // ... *)
Параметры для конструктора члена (здесь это table::table ()) помещаются в определение (не в описание) конструктора класса, вмещающего его (здесь это classdef::classdef()). Поле этого конструктор члена вызывается перед телом конструктра, задающего его список параметров.
Если есть еще члены, которым нужны списки параметров для конструкторов, их можно задать аналогично. Например:
class classdef (* table members; table friends; int no_of_members; // ... classdef(int size); ~classdef(); *);
Список параметров для членов разделяется запятыми (а не двоеточиями), и список инициализаторов для членов может представляться в произвольном порядке:
classdef::classdef(int size)
: friends(size), members(size) (* no_of_members = size; // ... *)
Порядок, в котором вызываются конструкторы, неопределен, поэтому не рекомендуется делать списки параметров с побочными эффектами:
classdef::classdef(int size) : friends(size=size/2), members(size); // дурной стиль (* no_of_members = size; // ... *)
Если конструктору для члена не нужно ни одного парамера, то никакого списка параметров задавать не надо. Например, поскольку table::table был определен с параметром по умолчнию 15, следующая запись является правильной:
classdef::classdef(int size) : members(size) (* no_of_members = size; // ... *)
и размер size таблицы friends будет равен 15.
Когда объект класса, содержащий объект класса, (напрмер, classdef) уничтожается, первым выполняется тело собтвенного деструктора объекта, а затем выполняются деструкторы членов.
Рассмотрим традиционную альтернативу тому, чтобы иметь объекты класса как члены, – иметь члены указатели и инициалзировать их в конструкторе:
class classdef (* table* members; table* friends; int no_of_members; // ... classdef(int size); ~classdef(); *);
classdef::classdef(int size) (* members = new table(size); friends = new table; // размер таблицы по умолчанию no_of_members = size; // ... *)
Так как таблицы создавались с помощью new, они должны уничтожаться с помощью delete:
classdef::~classdef() (* // ... delete members; delete friends; *)
Раздельно создаваемые объекты вроде этих могут оказаться полезными, но учтите, что members и friends указывают на одельные объекты, что требует для каждого из них действие по выделению памяти и ее освобождению. Кроме того, указатель плюс объект в свободной памяти занимают больше места, чем объект член.
class classdef (* table members; int no_of_members; // ... classdef(int size); ~classdef(); *);
Очевидное намерение состоит в том, что classdef должен содержать таблицу длиной size из членов members, а сложность – в том, как сделать так, чтобы конструктор table::table() вызывался с параметром size. Это делается так:
classdef::classdef(int size) : members(size) (* no_of_members = size; // ... *)
Параметры для конструктора члена (здесь это table::table ()) помещаются в определение (не в описание) конструктора класса, вмещающего его (здесь это classdef::classdef()). Поле этого конструктор члена вызывается перед телом конструктра, задающего его список параметров.
Если есть еще члены, которым нужны списки параметров для конструкторов, их можно задать аналогично. Например:
class classdef (* table members; table friends; int no_of_members; // ... classdef(int size); ~classdef(); *);
Список параметров для членов разделяется запятыми (а не двоеточиями), и список инициализаторов для членов может представляться в произвольном порядке:
classdef::classdef(int size)
: friends(size), members(size) (* no_of_members = size; // ... *)
Порядок, в котором вызываются конструкторы, неопределен, поэтому не рекомендуется делать списки параметров с побочными эффектами:
classdef::classdef(int size) : friends(size=size/2), members(size); // дурной стиль (* no_of_members = size; // ... *)
Если конструктору для члена не нужно ни одного парамера, то никакого списка параметров задавать не надо. Например, поскольку table::table был определен с параметром по умолчнию 15, следующая запись является правильной:
classdef::classdef(int size) : members(size) (* no_of_members = size; // ... *)
и размер size таблицы friends будет равен 15.
Когда объект класса, содержащий объект класса, (напрмер, classdef) уничтожается, первым выполняется тело собтвенного деструктора объекта, а затем выполняются деструкторы членов.
Рассмотрим традиционную альтернативу тому, чтобы иметь объекты класса как члены, – иметь члены указатели и инициалзировать их в конструкторе:
class classdef (* table* members; table* friends; int no_of_members; // ... classdef(int size); ~classdef(); *);
classdef::classdef(int size) (* members = new table(size); friends = new table; // размер таблицы по умолчанию no_of_members = size; // ... *)
Так как таблицы создавались с помощью new, они должны уничтожаться с помощью delete:
classdef::~classdef() (* // ... delete members; delete friends; *)
Раздельно создаваемые объекты вроде этих могут оказаться полезными, но учтите, что members и friends указывают на одельные объекты, что требует для каждого из них действие по выделению памяти и ее освобождению. Кроме того, указатель плюс объект в свободной памяти занимают больше места, чем объект член.
5.5.5 Вектора Объектов Класса
Чтобы описать вектор объектов класса, имеющего конструтор, этот класс должен иметь конструктор, который может вызваться без списка параметров. Нельзя использовать даже парметры по умолчанию. Например:
table tblvec[10];
будет ошибкой, так как для table::table() требуется целый параметр. Нет способа задать параметры конструктора в описании вектора. Чтобы можно было описывать вектор таблиц table, можно модифицировать описание table (#5.3.1), напрмер, так:
class table (* // ... void init(int sz); // как старый конструктор public: table(int sz) // как раньше, но без по умолчанию (* init(sz); *) table() // по умолчанию (* init(15); *) *)
Когда вектор уничтожается, деструктор должен вызываться для каждого элемента этого вектора. Для векторов, которые не были размещены с помощью new, это делается неявно. Однако для векторов в свободной памяти это не может быть сделано неявно, поскольку компилятор не может отличить указатель на один обект от указателя на первый элемент вектора объектов. Например:
void f() (* table* t1 = new table; table* t2 = new table[10]; delete t1; // одна таблица delete t2; // неприятность: 10 таблиц *)
В этом случае длину вектора должен задавать программист:
void g(int sz) (* table* t1 = new table; table* t2 = new table[sz]; delete t1; delete[] t2; *)
Но почему же компилятор не может найти число элементов вектора из объема выделенной памяти? Потому, что распределтель свободной памяти не является частью языка и может быть задан программистом.
table tblvec[10];
будет ошибкой, так как для table::table() требуется целый параметр. Нет способа задать параметры конструктора в описании вектора. Чтобы можно было описывать вектор таблиц table, можно модифицировать описание table (#5.3.1), напрмер, так:
class table (* // ... void init(int sz); // как старый конструктор public: table(int sz) // как раньше, но без по умолчанию (* init(sz); *) table() // по умолчанию (* init(15); *) *)
Когда вектор уничтожается, деструктор должен вызываться для каждого элемента этого вектора. Для векторов, которые не были размещены с помощью new, это делается неявно. Однако для векторов в свободной памяти это не может быть сделано неявно, поскольку компилятор не может отличить указатель на один обект от указателя на первый элемент вектора объектов. Например:
void f() (* table* t1 = new table; table* t2 = new table[10]; delete t1; // одна таблица delete t2; // неприятность: 10 таблиц *)
В этом случае длину вектора должен задавать программист:
void g(int sz) (* table* t1 = new table; table* t2 = new table[sz]; delete t1; delete[] t2; *)
Но почему же компилятор не может найти число элементов вектора из объема выделенной памяти? Потому, что распределтель свободной памяти не является частью языка и может быть задан программистом.
5.5.6 Небольшие Объекты
Когда вы используете много небольших объектов, размещамых в свободной памяти, то вы можете обнаружить, что ваша
программа тратит много времени выделяя и освобождая память под эти объекты. Первое решение – это обеспечить более хорший распределитель памяти общего назначения, второе для раработчика классов состоит в том, чтобы взять под контроль уравление свободной памятью для объектов некоторого класса с помощью подходящих конструкторов и деструкторов.
Рассмотрим класс name, который использовался в примерах table. Его можно было бы определить так:
struct name (* char* string; name* next; double value;
name(char*, double, name*); ~name(); *);
Программист может воспользоваться тем, что размещение и освобождение объектов заранее известного размера можно обрбатывать гораздо эффективнее (и по памяти, и по времени), чем с помощью общей реализации new и delete. Общая идея состоит в том, чтобы предварительно разместить «куски» из объектов name, а затем сцеплять их, чтобы свести выделение и освободение к простым операциям над связанным списком. Переменная nfree является вершиной списка неиспользованных name:
const NALL = 128; name* nfree;
Распределитель, используемый операцией new, хранит рамер объекта вместе с объектом, чтобы обеспечить правильную работу операции delete. С помощью распределителя, специализрованного для типа, можно избежать этих накладных расходов. Например, на моей машине следующий распределитель использует для хранения name 16 байт, тогда как для стандартного распрделителя свободной памяти нужно 20 байт. Вот как это можно сделать:
name::name(char* s, double v, name* n) (* register name* p = nfree; // сначала выделить
if (p) nfree = p-»next; else (* // выделить и сцепить name* q = (name*)new char[ NALL*sizeof(name) ]; for (p=nfree= amp;q[NALL-1]; q«p; p–) p-»next = p-1; (p+1)-»next = 0; *)
this = p; // затем инициализировать string = s; value = v; next = n; *)
Присвоение указателю this информирует компилятор о том, что программист взял себе управление, и что не надо использвать стандартный механизм распределения памяти. Конструктор name::name() обрабатывает только тот случай, когда name рамещается посредством new, но для большей части типов это всегда так. В #5.5.8 объясняется, как написать конструктор для обработки как размещения в свободной памяти, так и других видов размещения.
Заметьте, что просто как
name* q = new name[NALL];
память выделять нельзя, поскольку это приведет к бескнечной рекурсии, когда new вызовет name::name().
Освобождение памяти обычно тривиально:
name::~name() (* next = nfree; nfree = this; this = 0; *)
Присваивание указателю this 0 в деструкторе обеспечивет, что стандартный распределитель памяти не используется.
программа тратит много времени выделяя и освобождая память под эти объекты. Первое решение – это обеспечить более хорший распределитель памяти общего назначения, второе для раработчика классов состоит в том, чтобы взять под контроль уравление свободной памятью для объектов некоторого класса с помощью подходящих конструкторов и деструкторов.
Рассмотрим класс name, который использовался в примерах table. Его можно было бы определить так:
struct name (* char* string; name* next; double value;
name(char*, double, name*); ~name(); *);
Программист может воспользоваться тем, что размещение и освобождение объектов заранее известного размера можно обрбатывать гораздо эффективнее (и по памяти, и по времени), чем с помощью общей реализации new и delete. Общая идея состоит в том, чтобы предварительно разместить «куски» из объектов name, а затем сцеплять их, чтобы свести выделение и освободение к простым операциям над связанным списком. Переменная nfree является вершиной списка неиспользованных name:
const NALL = 128; name* nfree;
Распределитель, используемый операцией new, хранит рамер объекта вместе с объектом, чтобы обеспечить правильную работу операции delete. С помощью распределителя, специализрованного для типа, можно избежать этих накладных расходов. Например, на моей машине следующий распределитель использует для хранения name 16 байт, тогда как для стандартного распрделителя свободной памяти нужно 20 байт. Вот как это можно сделать:
name::name(char* s, double v, name* n) (* register name* p = nfree; // сначала выделить
if (p) nfree = p-»next; else (* // выделить и сцепить name* q = (name*)new char[ NALL*sizeof(name) ]; for (p=nfree= amp;q[NALL-1]; q«p; p–) p-»next = p-1; (p+1)-»next = 0; *)
this = p; // затем инициализировать string = s; value = v; next = n; *)
Присвоение указателю this информирует компилятор о том, что программист взял себе управление, и что не надо использвать стандартный механизм распределения памяти. Конструктор name::name() обрабатывает только тот случай, когда name рамещается посредством new, но для большей части типов это всегда так. В #5.5.8 объясняется, как написать конструктор для обработки как размещения в свободной памяти, так и других видов размещения.
Заметьте, что просто как
name* q = new name[NALL];
память выделять нельзя, поскольку это приведет к бескнечной рекурсии, когда new вызовет name::name().
Освобождение памяти обычно тривиально:
name::~name() (* next = nfree; nfree = this; this = 0; *)
Присваивание указателю this 0 в деструкторе обеспечивет, что стандартный распределитель памяти не используется.
5.5.7 Предостережение
Когда в конструкторе производится указателю this, значние this до этого присваивания неопределено. Таким образом, ссылка на член до этого присваивания неопределена и скорее всего приведет к катастрофе. Имеющийся компилятор не пытается убедиться в том, что присваивание указателю this происходит на всех траекториях выполнения:
mytype::mytype(int i) (* if (i) this = mytype_alloc(); // присваивание членам *);
откомпилируется, и при i==0 никакой объект размещен не будет.
Конструктор может определить, был ли он вызван операцией new, или нет. Если он вызван new, то указатель this на входе имеет нулевое значение, в противном случае this указывает на пространство, уже выделенное для объекта (например, на стек). Поэтому можно просто написать конструктор, который выделяет память, если (и только если) он был вызван через new. Напрмер:
mytype::mytype(int i) (* if (this == 0) this = mytype_alloc(); // присваивание членам *);
Эквивалентного средства, которое позволяет деструктору решить вопрос, был ли его объект создан с помощью new, не имеется, как нет и средства, позволяющего ему узнать, вызвала ли его delete, или он вызван объектом, выходящим из области видимости. Если для пользователя это существенно, то он может сохранить где-то соответствующую информацию для деструктора. Другой способ – когда пользователь обеспечивает, что объекты этого класса размещаются только соответствующим образом. Если удается справиться с первой проблемой, то второй способ интреса не представляет.
Если тот, кто реализует класс, является одновременно и его единственным пользователем, то имеет смысл упростить класс, исходя из предположений о его использовании. Когда класс разрабатывается для более широкого использования, таких допущений, как правило, лучше избегать.
mytype::mytype(int i) (* if (i) this = mytype_alloc(); // присваивание членам *);
откомпилируется, и при i==0 никакой объект размещен не будет.
Конструктор может определить, был ли он вызван операцией new, или нет. Если он вызван new, то указатель this на входе имеет нулевое значение, в противном случае this указывает на пространство, уже выделенное для объекта (например, на стек). Поэтому можно просто написать конструктор, который выделяет память, если (и только если) он был вызван через new. Напрмер:
mytype::mytype(int i) (* if (this == 0) this = mytype_alloc(); // присваивание членам *);
Эквивалентного средства, которое позволяет деструктору решить вопрос, был ли его объект создан с помощью new, не имеется, как нет и средства, позволяющего ему узнать, вызвала ли его delete, или он вызван объектом, выходящим из области видимости. Если для пользователя это существенно, то он может сохранить где-то соответствующую информацию для деструктора. Другой способ – когда пользователь обеспечивает, что объекты этого класса размещаются только соответствующим образом. Если удается справиться с первой проблемой, то второй способ интреса не представляет.
Если тот, кто реализует класс, является одновременно и его единственным пользователем, то имеет смысл упростить класс, исходя из предположений о его использовании. Когда класс разрабатывается для более широкого использования, таких допущений, как правило, лучше избегать.
5.5.8 Объекты Переменного Размера
Когда пользователь берет управление распределением и овобождением памяти, он может конструировать объекты размеры, которых во время компиляции недетерминирован. В предыдущих примерах вмещающие (или контейнерные – перев.) классы vector, stack, intset и table реализовывались как структуры доступа фиксированного размера, содержащие указатели на реальную пмять. Это подразумевает, что для создания таких объектов в свободной памяти необходимо две операции по выделению памяти, и что любое обращение к хранимой информации будет содержать дополнительную косвенную адресацию. Например:
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; *) *);
Если каждый объект класса размещается в свободной памти, это делать не нужно. Вот другой вариант:
class char_stack (* int size; char* top; char s[1]; public: char_stack(int sz); void push(char c) (* *top++ = c; *) char pop() (* return *–top; *) *);
char_stack::char_stack(int sz) (* if (this) error(«стек не в свободной памяти»); if (sz « 1) error(„размер стека « 1“); this = (char_stack*) new char[sizeof(char_stack)+sz-1]; size = sz; top = s; *)
Заметьте, что деструктор больше не нужен, поскольку пмять, которую использует char_stack, может освободить delete без всякого содействия со стороны программиста.
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; *) *);
Если каждый объект класса размещается в свободной памти, это делать не нужно. Вот другой вариант:
class char_stack (* int size; char* top; char s[1]; public: char_stack(int sz); void push(char c) (* *top++ = c; *) char pop() (* return *–top; *) *);
char_stack::char_stack(int sz) (* if (this) error(«стек не в свободной памяти»); if (sz « 1) error(„размер стека « 1“); this = (char_stack*) new char[sizeof(char_stack)+sz-1]; size = sz; top = s; *)
Заметьте, что деструктор больше не нужен, поскольку пмять, которую использует char_stack, может освободить delete без всякого содействия со стороны программиста.
5.6 Упражнения
1. (*1) Модифицируйте настольный калькулятор из Главы 3, чтобы использовать класс table.
2. (*1) Разработайте tnode (#с.8.5) как класс с контрукторами, деструкторами и т.п. Определите дерево из tnode'ов как класс с конструкторами, деструкторами и т.п.
3. (*1) Преобразуйте класс intset (#5.3.2) в множество строк.
4. (*1) Преобразуйте класс intset в множество узлов node, где node – определяемая вами структура.
5. (*3) Определите класс для анализа, хранения, вычислния и печати простых арифметических выражений, состоящих из целых констант и операций +, -, * и /. Открытый итерфейс должен выглядеть примерно так:
class expr (* // ... public: expr(char*); int eval(); void print(); *) Параметр строка конструктора expr::expr() является выржением. Функция expr::eval() возвращает значение выражния, а expr::print() печатает представление выражения в cout. Программа может выглядеть, например, так:
expr x(«123/4+123*4-3»); cout «„ "x = " «« x.eval() «« «\n“; x.print();
Определите класс expr два раза: один раз используя в кчестве представления связанный список узлов, а другой раз – символьную строку. Поэкспериментируйте с разными способами печати выражения: с полностью расставленными скобками,в постфиксной записи,в ассемблерном коде и т.д.
6. (*1) Определите класс char_queue (символьная очередь) таким образом, чтобы открытый интерфейс не зависел от представления. Реализуйте char_queue как (1) связанный список и как (2) вектор. О согласованности не заботтесь.
7. (*2) Определите класс histogram (гистограмма), в ктором ведется подсчет чисел в определенных интервалах, которые задаются как параметры конструктора histogram. Обеспечьте функцию вывода гистограммы на печать. Сделате обработку значений, выходящих за границы. Подсказка: «task.h».
8. (*2) Определите несколько классов, предоставляющих случайные числа с определенными распределениями. Каждый класс имеет конструктор, задающий параметры распределния, и функцию draw, которая возвращает «следующее» знчение. Подсказка: «task.h». Посмотрите также класс intset.
9. (*2) Перепишите пример date (#5.8.2), пример char_stack (#5.2.5) и пример intset (#5.3.2) не исползуя функций членов (даже конструкторов и деструкторов). Используйте только class и friend. Сравните с версиями, в которых использовались функции члены.
10. (*3) Для какого-нибудь языка спроектируйте класс таблица имен и класс вхождение в таблицу имен. Чтобы посмотреть, как на самом деле выглядит таблица имен, посмотрите на компилятор этого языка.
11. (*2) Модифицируйте класс выражение из Упражнения 5 так, чтобы обрабатывать переменные и операцию присваивния =. Используйте класс таблица имен из Упражнения 10.
12. (*1) Дана программа:
#include «stream.h»
main() (* cout «„ «Hello, world\n“; *)
модифицируйте ее, чтобы получить выдачу
Initialize Hello, world Clean up
Не делайте никаких изменений в main().
2. (*1) Разработайте tnode (#с.8.5) как класс с контрукторами, деструкторами и т.п. Определите дерево из tnode'ов как класс с конструкторами, деструкторами и т.п.
3. (*1) Преобразуйте класс intset (#5.3.2) в множество строк.
4. (*1) Преобразуйте класс intset в множество узлов node, где node – определяемая вами структура.
5. (*3) Определите класс для анализа, хранения, вычислния и печати простых арифметических выражений, состоящих из целых констант и операций +, -, * и /. Открытый итерфейс должен выглядеть примерно так:
class expr (* // ... public: expr(char*); int eval(); void print(); *) Параметр строка конструктора expr::expr() является выржением. Функция expr::eval() возвращает значение выражния, а expr::print() печатает представление выражения в cout. Программа может выглядеть, например, так:
expr x(«123/4+123*4-3»); cout «„ "x = " «« x.eval() «« «\n“; x.print();
Определите класс expr два раза: один раз используя в кчестве представления связанный список узлов, а другой раз – символьную строку. Поэкспериментируйте с разными способами печати выражения: с полностью расставленными скобками,в постфиксной записи,в ассемблерном коде и т.д.
6. (*1) Определите класс char_queue (символьная очередь) таким образом, чтобы открытый интерфейс не зависел от представления. Реализуйте char_queue как (1) связанный список и как (2) вектор. О согласованности не заботтесь.
7. (*2) Определите класс histogram (гистограмма), в ктором ведется подсчет чисел в определенных интервалах, которые задаются как параметры конструктора histogram. Обеспечьте функцию вывода гистограммы на печать. Сделате обработку значений, выходящих за границы. Подсказка: «task.h».
8. (*2) Определите несколько классов, предоставляющих случайные числа с определенными распределениями. Каждый класс имеет конструктор, задающий параметры распределния, и функцию draw, которая возвращает «следующее» знчение. Подсказка: «task.h». Посмотрите также класс intset.
9. (*2) Перепишите пример date (#5.8.2), пример char_stack (#5.2.5) и пример intset (#5.3.2) не исползуя функций членов (даже конструкторов и деструкторов). Используйте только class и friend. Сравните с версиями, в которых использовались функции члены.
10. (*3) Для какого-нибудь языка спроектируйте класс таблица имен и класс вхождение в таблицу имен. Чтобы посмотреть, как на самом деле выглядит таблица имен, посмотрите на компилятор этого языка.
11. (*2) Модифицируйте класс выражение из Упражнения 5 так, чтобы обрабатывать переменные и операцию присваивния =. Используйте класс таблица имен из Упражнения 10.
12. (*1) Дана программа:
#include «stream.h»
main() (* cout «„ «Hello, world\n“; *)
модифицируйте ее, чтобы получить выдачу
Initialize Hello, world Clean up
Не делайте никаких изменений в main().
Глава 6 Перегрузка Операций
Здесь водятся Драконы!
старинная карта
В этой главе описывается аппарат, предоставляемый в С++ для перегрузки операций. Программист может определять смысл операций при их применении к объектам определенного класса. Кроме арифметических, можно определять еще и логические опрации, операции сравнения, вызова () и индексирования [], а также можно переопределять присваивание и инициализацию. Моно определить явное и неявное преобразование между определямыми пользователем и основными типами. Показано, как опредлить класс, объект которого не может быть никак иначе скопирован или уничтожен кроме как специальными определенными пользователем функциями.
6.1 Введение
Часто программы работают с объектами, которые являются конкретными представлениями абстрактных понятий. Например, тип данных int в С++ вместе с операциями +, -, *, / и т.д. предоставляет реализацию (ограниченную) математического понтия целых чисел. Такие понятия обычно включают в себя мнжество операций, которые кратко, удобно и привычно предсталяют основные действия над объектами. К сожалению, язык программирования может непосредственно поддерживать лишь очень малое число таких понятий. Например, такие понятия, как комплексная арифметика, матричная алгебра, логические сигналы и строки не получили прямой поддержки в С++. Классы дают средство спецификации в С++ представления неэлементарных обектов вместе с множеством действий, которые могут над этими объектами выполняться. Иногда определение того, как действуют операции на объекты классов, позволяет программисту обеспчить более общепринятую и удобную запись для манипуляции обектами классов, чем та, которую можно достичь используя лишь основную функциональную запись. Например:
class complex (* double re, im; public: complex(double r, double i) (* re=r; im=i; *) friend complex operator+(complex, complex); friend complex operator*(complex, complex); *);
определяет простую реализацию понятия комплексного чила, в которой число представляется парой чисел с плавающей точкой двойной точности, работа с которыми осуществляется посредством операций + и * (и только). Программист задает смысл операций + и * с помощью определения функций с именами operator+ и operator*. Если, например, даны b и c типа complex, то b+c означает (по определению) operator+(b,c). Тперь есть возможность приблизить общепринятую интерпретацию комплексных выражений. Например:
void f() (* complex a = complex(1, 3.1); complex b = complex(1.2, 2); complex c = b;
a = b+c; b = b+c*a; c = a*b+complex(1,2); *)
Выполняются обычные правила приоритетов, поэтому второй оператор означает b=b+(c*a), а не b=(b+c)*a.
class complex (* double re, im; public: complex(double r, double i) (* re=r; im=i; *) friend complex operator+(complex, complex); friend complex operator*(complex, complex); *);
определяет простую реализацию понятия комплексного чила, в которой число представляется парой чисел с плавающей точкой двойной точности, работа с которыми осуществляется посредством операций + и * (и только). Программист задает смысл операций + и * с помощью определения функций с именами operator+ и operator*. Если, например, даны b и c типа complex, то b+c означает (по определению) operator+(b,c). Тперь есть возможность приблизить общепринятую интерпретацию комплексных выражений. Например:
void f() (* complex a = complex(1, 3.1); complex b = complex(1.2, 2); complex c = b;
a = b+c; b = b+c*a; c = a*b+complex(1,2); *)
Выполняются обычные правила приоритетов, поэтому второй оператор означает b=b+(c*a), а не b=(b+c)*a.
6.2 Функции Операции
Можно описывать функции, определяющие значения следующих операций:
+ – * / % ^ amp; ! ~ ! = « » += -= *= /= %= ^= amp;= != «„ “» »»= «„= == != «= “= amp; amp; !! ++ – [] () new delete
Последние четыре – это индексирование (#6.7), вызов функции (#6.8), выделение свободной памяти и освобождение свободной памяти (#3.2.6). Изменить приоритеты перечисленных операций невозможно, как невозможно изменить и синтаксис вражений. Нельзя, например, определить унарную операцию % или бинарную !. Невозможно определить новые лексические символы операций, но в тех случаях, когда множество операций недостточно, вы можете использовать запись вызова функции. Исползуйте например, не **, а pow(). Эти ограничения могут покзаться драконовскими, но более гибкие правила могут очень легко привести к неоднозначностям. Например, на первый взгляд определение операции **, означающей возведение в степень, мжет показаться очевидной и простой задачей, но подумайте еще раз. Должна ли ** связываться влево (как в Фортране) или вправо (как в Алголе)? Выражение a**p должно интерпретирваться как a*(*p) или как (a)**(p)?
Имя функции операции есть ключевое слово operator (то есть, операция), за которым следует сама операция, например, operator««. Функция операция описывается и может вызываться так же, как любая другая функция. Использование операции – это лишь сокращенная запись явного вызова функции операции. Например:
void f(complex a, complex b) (* complex c = a + b; // сокращенная запись complex d = operator+(a,b); // явный вызов *)
При наличии предыдущего описания complex оба инициализтора являются синонимами.
+ – * / % ^ amp; ! ~ ! = « » += -= *= /= %= ^= amp;= != «„ “» »»= «„= == != «= “= amp; amp; !! ++ – [] () new delete
Последние четыре – это индексирование (#6.7), вызов функции (#6.8), выделение свободной памяти и освобождение свободной памяти (#3.2.6). Изменить приоритеты перечисленных операций невозможно, как невозможно изменить и синтаксис вражений. Нельзя, например, определить унарную операцию % или бинарную !. Невозможно определить новые лексические символы операций, но в тех случаях, когда множество операций недостточно, вы можете использовать запись вызова функции. Исползуйте например, не **, а pow(). Эти ограничения могут покзаться драконовскими, но более гибкие правила могут очень легко привести к неоднозначностям. Например, на первый взгляд определение операции **, означающей возведение в степень, мжет показаться очевидной и простой задачей, но подумайте еще раз. Должна ли ** связываться влево (как в Фортране) или вправо (как в Алголе)? Выражение a**p должно интерпретирваться как a*(*p) или как (a)**(p)?
Имя функции операции есть ключевое слово operator (то есть, операция), за которым следует сама операция, например, operator««. Функция операция описывается и может вызываться так же, как любая другая функция. Использование операции – это лишь сокращенная запись явного вызова функции операции. Например:
void f(complex a, complex b) (* complex c = a + b; // сокращенная запись complex d = operator+(a,b); // явный вызов *)
При наличии предыдущего описания complex оба инициализтора являются синонимами.
6.2.1 Бинарные и Унарные Операции
Бинарная операция может быть определена или как функция член, получающая один параметр, или как функция друг, получющая два параметра. Таким образом, для любой бинарной оперции @ aa@bb может интерпретироваться или как aa.operator@(bb), или как operator@(aa,bb). Если определены обе, то aa@bb является ошибкой. Унарная операция, префиксная или постфиксная, может быть определена или как функция член, не получающая параметров, или как функция друг, получающая один параметр. Таким образом, для любой унарной операции @ aa @ или @aa может интерпретироваться или как aa.operator@(), или как operator@(aa). Если определено и то, и другое, то и aa@, и @aa являются ошибками. Рассмотрим следующие примеры:
class X (* // друзья
friend X operator-(X); // унарный минус friend X operator-(X,X); // бинарный минус friend X operator-(); // ошибка: нет операндов
friend X operator-(X,X,X); // ошибка: тернарная
// члены (с неявным первым параметром: this)
X* operator amp;(); // унарное amp; (взятие адреса) X operator amp;(X); // бинарное amp; (операция И) X operator amp;(X,X); // ошибка: тернарное
*);
Когда операции ++ и – перегружены, префиксное использвание и постфиксное различить невозможно.
class X (* // друзья
friend X operator-(X); // унарный минус friend X operator-(X,X); // бинарный минус friend X operator-(); // ошибка: нет операндов
friend X operator-(X,X,X); // ошибка: тернарная
// члены (с неявным первым параметром: this)
X* operator amp;(); // унарное amp; (взятие адреса) X operator amp;(X); // бинарное amp; (операция И) X operator amp;(X,X); // ошибка: тернарное
*);
Когда операции ++ и – перегружены, префиксное использвание и постфиксное различить невозможно.
6.2.2 Предопределенный Смысл Операций
Относительно смысла операций, определяемых пользоватлем, не делается никаких предположений. В частности, посколку не предполагается, что перегруженное = реализует присваивание ее первому операнду, не делается никакой провеки, чтобы удостовериться, является ли этот операнд lvalue (#с.6).
Значения некоторых встроенных операций определены как равносильные определенным комбинациям других операций над тми же аргументами. Например, если a является int, то ++a оначает a+=1, что в свою очередь означает a=a+1. Такие соотншения для определяемых пользователем операций не выполняются, если только не случилось так, что пользователь сам определил их таким образом. Например, определение operator+= () для тпа complex не может быть выведено из определений complex::operator+() и complex::operator=().
По историческому совпадению операции = и amp; имеют опредленный смысл для объектов классов. Никакого элегантного спсоба «не определить» эти две операции не существует. Их моно, однако, сделать недееспособными для класса X. Можно, например, описать X::operator amp;(), не задав ее определения. Если где-либо будет браться адрес объекта класса X, то компновщик обнаружит отсутствие определения*. Или, другой способ, можно определить X::operator amp;() так, чтобы она вызывала ошику во время выполнения.
____________________ * В некоторых системах компоновщик настолько «умен», что ругается, даже если неопределена неиспользуемая функция. В таких системах этим методом воспользоваться нельзя. (прим атора)
Значения некоторых встроенных операций определены как равносильные определенным комбинациям других операций над тми же аргументами. Например, если a является int, то ++a оначает a+=1, что в свою очередь означает a=a+1. Такие соотншения для определяемых пользователем операций не выполняются, если только не случилось так, что пользователь сам определил их таким образом. Например, определение operator+= () для тпа complex не может быть выведено из определений complex::operator+() и complex::operator=().
По историческому совпадению операции = и amp; имеют опредленный смысл для объектов классов. Никакого элегантного спсоба «не определить» эти две операции не существует. Их моно, однако, сделать недееспособными для класса X. Можно, например, описать X::operator amp;(), не задав ее определения. Если где-либо будет браться адрес объекта класса X, то компновщик обнаружит отсутствие определения*. Или, другой способ, можно определить X::operator amp;() так, чтобы она вызывала ошику во время выполнения.
____________________ * В некоторых системах компоновщик настолько «умен», что ругается, даже если неопределена неиспользуемая функция. В таких системах этим методом воспользоваться нельзя. (прим атора)
6.2.3 Операции и Определяемые Пользователем Типы
Функция операция должна или быть членом, или получать в качестве параметра по меньшей мере один объект класса (фунциям, которые переопределяют операции new и delete, это длать необязательно). Это правило гарантирует, что пользовтель не может изменить смысл никакого выражения, не включающего в себя определенного пользователем типа. В часности, невозможно определить функцию, которая действует ислючительно на указатели.
Функция операция, первым параметром которой предполагется основной встроенный тип, не может быть функцией членом. Рассмотрим, например, сложение комплексной переменной aa с целым 2: aa+2, при подходящим образом описанной функции члне, может быть проинтерпретировано как aa.operator+(2), но с 2+aa это не может быть сделано, потому что нет такого класса int, для которого можно было бы определить + так, чтобы это означало 2.operator+(aa). Даже если бы такой тип был, то для
того, чтобы обработать и 2+aa и aa+2, понадобилось бы две различных функции члена. Так как компилятор не знает смысла +, определяемого пользователем, то не может предполагать, что он коммутативен, и интерпретировать 2+aa как aa+2. С этим примером могут легко справиться функции друзья.
Все функции операции по определению перегружены. Функция операция задает новый смысл операции в дополнение к встроеному определению, и может существовать несколько функций опраций с одним и тем же именем, если в типах их параметров имеются отличия, различимые для компилятора, чтобы он мог различать их при обращении (см. #4.6.7).
Функция операция, первым параметром которой предполагется основной встроенный тип, не может быть функцией членом. Рассмотрим, например, сложение комплексной переменной aa с целым 2: aa+2, при подходящим образом описанной функции члне, может быть проинтерпретировано как aa.operator+(2), но с 2+aa это не может быть сделано, потому что нет такого класса int, для которого можно было бы определить + так, чтобы это означало 2.operator+(aa). Даже если бы такой тип был, то для
того, чтобы обработать и 2+aa и aa+2, понадобилось бы две различных функции члена. Так как компилятор не знает смысла +, определяемого пользователем, то не может предполагать, что он коммутативен, и интерпретировать 2+aa как aa+2. С этим примером могут легко справиться функции друзья.
Все функции операции по определению перегружены. Функция операция задает новый смысл операции в дополнение к встроеному определению, и может существовать несколько функций опраций с одним и тем же именем, если в типах их параметров имеются отличия, различимые для компилятора, чтобы он мог различать их при обращении (см. #4.6.7).
6.3 Определяемое Пользователем Преобразование Типа
Приведенная во введении реализация комплексных чисел слишком ограничена, чтобы она могла устроить кого-либо, потому ее нужно расширить. Это будет в основном повторением описанных выше методов. Например:
class complex (* double re, im; public: complex(double r, double i) (* re=r; im=i; *)
friend complex operator+(complex, complex); friend complex operator+(complex, double); friend complex operator+(double, complex);
friend complex operator-(complex, complex); friend complex operator-(complex, double); friend complex operator-(double, complex); complex operator-() // унарный -
friend complex operator*(complex, complex); friend complex operator*(complex, double); friend complex operator*(double, complex);
// ... *);
Теперь, имея описание complex, мы можем написать:
void f() (* complex a(1,1), b(2,2), c(3,3), d(4,4), e(5,5); a = -b-c; b = c*2.0*c; c = (d+e)*a; *)
Но писать функцию для каждого сочетания complex и double, как это делалось выше для operator+(), невыносимо нудно. Кроме того, близкие к реальности средства комплексной арифметики должны предоставлять по меньшей мере дюжину таких функций. Посмотрите, например, на тип complex, описанный в «complex.h».
class complex (* double re, im; public: complex(double r, double i) (* re=r; im=i; *)
friend complex operator+(complex, complex); friend complex operator+(complex, double); friend complex operator+(double, complex);
friend complex operator-(complex, complex); friend complex operator-(complex, double); friend complex operator-(double, complex); complex operator-() // унарный -
friend complex operator*(complex, complex); friend complex operator*(complex, double); friend complex operator*(double, complex);
// ... *);
Теперь, имея описание complex, мы можем написать:
void f() (* complex a(1,1), b(2,2), c(3,3), d(4,4), e(5,5); a = -b-c; b = c*2.0*c; c = (d+e)*a; *)
Но писать функцию для каждого сочетания complex и double, как это делалось выше для operator+(), невыносимо нудно. Кроме того, близкие к реальности средства комплексной арифметики должны предоставлять по меньшей мере дюжину таких функций. Посмотрите, например, на тип complex, описанный в «complex.h».
6.3.1 Конструкторы
Альтернативу использованию нескольких функций (перегрженных) составляет описание конструктора, который по заданнму double создает complex. Например:
class complex (* // ... complex(double r) (* re=r; im=0; *) *);
Конструктор, требующий только один параметр, необязтельно вызывать явно:
complex z1 = complex(23); complex z2 = 23;
И z1, и z2 будут инициализированы вызовом complex(23).
Конструктор – это предписание, как создавать значение данного типа. Когда требуется значение типа, и когда такое значение может быть создано конструктором, тогда, если такое значение дается для присваивания, вызывается конструктор. Например, класс complex можно было бы описать так:
class complex (* double re, im; public: complex(double r, double i = 0) (* re=r; im=i; *)
friend complex operator+(complex, complex); friend complex operator*(complex, complex); *);
и действия, в которые будут входить переменные complex и целые константы, стали бы допустимы. Целая константа будет интерпретироваться как complex с нулевой мнимой частью. Наример, a=b*2 означает:
a=operator*( b, complex( double(2), double(0) ) )
Определенное пользователем преобразование типа применется неявно только тогда, когда оно является единственным.
Объект, сконструированный с помощью явного или неявного вызова конструктора, является автоматическим и будет уничтжен при первой возможности, обычно сразу же после оператора, в котором он был создан.
class complex (* // ... complex(double r) (* re=r; im=0; *) *);
Конструктор, требующий только один параметр, необязтельно вызывать явно:
complex z1 = complex(23); complex z2 = 23;
И z1, и z2 будут инициализированы вызовом complex(23).
Конструктор – это предписание, как создавать значение данного типа. Когда требуется значение типа, и когда такое значение может быть создано конструктором, тогда, если такое значение дается для присваивания, вызывается конструктор. Например, класс complex можно было бы описать так:
class complex (* double re, im; public: complex(double r, double i = 0) (* re=r; im=i; *)
friend complex operator+(complex, complex); friend complex operator*(complex, complex); *);
и действия, в которые будут входить переменные complex и целые константы, стали бы допустимы. Целая константа будет интерпретироваться как complex с нулевой мнимой частью. Наример, a=b*2 означает:
a=operator*( b, complex( double(2), double(0) ) )
Определенное пользователем преобразование типа применется неявно только тогда, когда оно является единственным.
Объект, сконструированный с помощью явного или неявного вызова конструктора, является автоматическим и будет уничтжен при первой возможности, обычно сразу же после оператора, в котором он был создан.
6.3.2 Операции Преобразования
Использование конструктора для задания преобразования типа является удобным, но имеет следствия, которые могут окзаться нежелательными:
1. Не может быть неявного преобразования из определеного пользователем типа в основной тип (поскольку осноные типы не являются классами)
2. Невозможно задать преобразование из нового типа в старый, не изменяя описание старого
3. Невозможно иметь конструктор с одним параметром, не имея при этом преобразования.
Последнее не является серьезной проблемой, а с первыми двумя можно справиться, определив для исходного типа операцию преобразования. Функция член X::operator T(), где T – имя тпа, определяет преобразование из X в T. Например, можно опрделить тип tiny (крошечный), который может иметь значение только в диапазоне 0...63, но все равно может свободно сочтаться в целыми в арифметических операциях:
1. Не может быть неявного преобразования из определеного пользователем типа в основной тип (поскольку осноные типы не являются классами)
2. Невозможно задать преобразование из нового типа в старый, не изменяя описание старого
3. Невозможно иметь конструктор с одним параметром, не имея при этом преобразования.
Последнее не является серьезной проблемой, а с первыми двумя можно справиться, определив для исходного типа операцию преобразования. Функция член X::operator T(), где T – имя тпа, определяет преобразование из X в T. Например, можно опрделить тип tiny (крошечный), который может иметь значение только в диапазоне 0...63, но все равно может свободно сочтаться в целыми в арифметических операциях: