Бинарные и унарные операции
Бинарную операцию можно определить как функцию-член с одним параметром, или как глобальную функцию с двумя параметрами. Значит, для любой бинарной операции @ выражение aa @ bb интерпретируется либо как aa.operator(bb), либо как operator@(aa,bb). Если определены обе функции, то выбор интерпретации происходит по правилам сопоставления параметров (§R.13.2). Префиксная или постфиксная унарная операция может определяться как функция-член без параметров, или как глобальная функция с одними параметром. Для любой префиксной унарной операции @ выражение @aa интерпретируется либо как aa.operator@(), либо как operator@(aa). Если определены обе функции, то выбор интерпретации происходит по правилам сопоставления параметров (§R.13.2). Для любой постфиксной унарной операции @ выражение @aa интерпретируется либо как aa.operator@(int), либо как operator@(aa,int). Подробно это объясняется в §7.10. Если определены обе функции, то выбор интерпретации происходит по правилам сопоставления параметров (§13.2). Операцию можно определить только в соответствии с синтаксическими правилами, имеющимися для нее в грамматике С++.
В частности, нельзя определить % как унарную операцию, а + как тернарную. Проиллюстрируем сказанное примерами:
class X { // члены (неявно используется указатель `this'):
X* operator&(); // префиксная унарная операция & // (взятие адреса) X operator&(X); // бинарная операция & (И поразрядное) X operator++(int); // постфиксный инкремент X operator&(X,X); // ошибка: & не может быть тернарной X operator/(); // ошибка: / не может быть унарной };
// глобальные функции (обычно друзья)
X operator-(X); // префиксный унарный минус X operator-(X,X); // бинарный минус X operator--(X&,int); // постфиксный инкремент X operator-(); // ошибка: нет операнда X operator-(X,X,X); // ошибка: тернарная операция X operator%(X); // ошибка: унарная операция %
Операция [] описывается в §7.7, операция () в §7.8, операция -> в §7.9, а операции ++ и -- в §7.10.
Большие объекты
При выполнении любой бинарной операции для типа complex реализующей эту операцию функции будут передаваться как параметры копии обоих операндов. Дополнительные расходы, вызванные копированием двух значений типа double, заметны, хотя по всей видимости допустимы.
К сожалению представление не всех классов является столь удобно компактным. Чтобы избежать избыточного копирования, можно определять функции с параметрами типа ссылки:
class matrix { double m[4][4]; public: matrix(); friend matrix operator+(const matrix&, const matrix&); friend matrix operator*(const matrix&, const matrix&); };
Ссылки позволяют без излишнего копирования использовать выражения с обычными арифметическими операциями и для больших объектов. Указатели для этой цели использовать нельзя, т.к. невозможно переопределить интерпретацию операции, если она применяется к указателю. Операцию плюс для матриц можно определить так:
matrix operator+(const matrix& arg1, const matrix& arg2) { matrix sum; for (int i = 0; i<4; i++) for (int j=0; j<4; j++) sum.m[i] [j] = arg1.m[i][j] + arg2.m[i][j]; return sum; }
Здесь в функции operator+() операнды выбираются по ссылке, а возвращается само значение объекта. Более эффективным решением был бы возврат тоже ссылки:
class matrix { // ... friend matrix& operator+(const matrix&, const matrix&); friend matrix& operator*(const matrix&, const matrix&); };
Это допустимо, но возникает проблема с выделением памяти. Поскольку ссылка на результат операции будет передаваться как ссылка на возвращаемое функцией значение, оно не может быть автоматической переменной этой функции. Поскольку операция может использоваться неоднократно в одном выражении, результат не может быть и локальной статической переменной. Как правило, результат будет записываться в отведенный в свободной памяти объект. Обычно бывает дешевле (по затратам на время выполнения и память данных и команд) копировать результирующее значение, чем размещать его в свободной памяти и затем в конечном счете освобождать выделенную память. К тому же этот способ проще запрограммировать.
Друзья и члены
В заключении можно обсудить, когда при обращении в закрытую часть пользовательского типа стоит использовать функции-члены, а когда функции-друзья. Некоторые функции, например конструкторы, деструкторы и виртуальные функции (§R.12), обязаны быть членами, но для других есть возможность выбора. Поскольку, описывая функцию как член, мы не вводим нового глобального имени, при отсутствии других доводов следует использовать функции-члены.
Рассмотрим простой класс X:
class X { // ...
X(int);
int m1(); int m2() const;
friend int f1(X&); friend int f2(const X&); friend int f3(X); };
Вначале укажем, что члены X::m1() и X::m2() можно вызывать только для объектов класса X. Преобразование X(int) не будет применяться к объекту, для которого вызваны X::m1() или X::m2():
void g() { 1.m1(); // ошибка: X(1).m1() не используется 1.m2(); // ошибка: X(1).m2() не используется }
Глобальная функция f1() имеет то же свойство (§4.6.3), поскольку ее параметр - ссылка без спецификации const. С функциями f2() и f3() ситуация иная:
void h() { f1(1); // ошибка: f1(X(1)) не используется f2(1); // нормально: f2(X(1)); f3(1); // нормально: f3(X(1)); }
Следовательно операция, изменяющая состояние объекта класса, должна быть членом или глобальной функцией с параметром-ссылкой без спецификации const. Операции над основными типами, которые требуют в качестве операндов адреса (=, *, ++ и т.д.), для пользовательских типов естественно определять как члены.
Обратно, если требуется неявное преобразование типа для всех операндов некоторой операции, то реализующая ее функция должна быть не членом, а глобальной функцией и иметь параметр типа ссылки со спецификацией const или нессылочный параметр. Так обычно обстоит дело с функциями, реализующими операции, которые для основных типов не требуют адресов в качестве операндов (+, -, || и т.д.).
Если операции преобразования типа не определены, то нет неопровержимых доводов в пользу функции-члена перед функцией-другом с параметром-ссылкой и наоборот. Бывает, что программисту просто одна форма записи вызова нравится больше, чем другая. Например, многим для обозначения функции обращения матрицы m больше нравится запись inv(m), чем m.inv(). Конечно, если функция inv() обращает саму матрицу m, а не возвращает новую, обратную m, матрицу, то inv() должна быть членом.
При всех прочих равных условиях лучше все-таки остановиться на функции-члене. Можно привести такие доводы. Нельзя гарантировать, что когда-нибудь не будет определена операция обращения. Нельзя во всех случаях гарантировать, что будущие изменения не повлекут за собой изменения в состоянии объекта. Запись вызова функции-члена ясно показывает программисту, что объект может быть изменен, тогда как запись с параметром-ссылкой далеко не столь очевидна. Далее, выражения допустимые в функции-члене могут быть существенно короче эквивалентных выражений в глобальной функции. Глобальная функция должна использовать явно заданные параметры, а в функции-члене можно неявно использовать указатель this. Наконец, поскольку имена членов не являются глобальными именами, они обычно оказываются короче, чем имен глобальных функций.
Индексация
Операторная функция operator[] задает для объектов классов интерпретацию индексации. Второй параметр этой функций (индекс) может иметь произвольный тип. Это позволяет, например, определять ассоциативные массивы. В качестве примера можно переписать определение из §2.3.10, где ассоциативный массив использовался в небольшой программе, подсчитывающей число вхождений слов в файле.
Там для этого использовалась функция. Мы определим настоящий тип ассоциативного массива:
class assoc { struct pair { char* name; int val; };
pair* vec; int max; int free;
assoc(const assoc&); // предотвращает копирование assoc& operator=(const assoc&); // предотвращает копирование public: assoc(int); int& operator[](const char*); void print_all(); };
В объекте assoc хранится вектор из структур pair размером max.
В переменной free хранится индекс первого свободного элемента вектора.
Чтобы предотвратить копирование объектов assoc, конструктор копирования и операция присваивания описаны как частные. Конструктор выглядит так:
assoc::assoc(int s) { max = (s<16) ? 16 : s; free = 0; vec = new pair[max]; }
В реализации используется все тот же неэффективный алгоритм поиска, что и в §2.3.10. Но теперь, если вектор переполняется, объект assoc увеличивается:
#include <string.h>
int& assoc::operator[](const char* p) /* работает с множеством пар (структур pair): проводит поиск p, возвращает ссылку на целое значение из найденной пары, создает новую пару, если p не найдено */ { register pair* pp;
for (pp=&vec[free-1]; vec<=pp; pp-- ) if (strcmp(p,pp->name) == 0) return pp->val; if (free == max) { //переполнение: вектор увеличивается pair* nvec = new pair[max*2]; for (int i=0; i<max; i++) nvec[i] = vec[i]; delete vec; vec = nvec; max = 2*max; }
pp = &vec[free++]; pp->name = new char[strlen(p)+1]; strcpy(pp->name,p); pp->val = 0; // начальное значение = 0 return pp->val; }
Поскольку представление объекта assoc скрыто от пользователя, нужно иметь возможность напечатать его каким-то образом. В следующем разделе будет показано как определить настоящий итератор для такого объекта.
Здесь же мы ограничимся простой функцией печати:
void assoc::print_all() { for (int i = 0; i<free; i++) cout << vec[i].name << ": " << vec[i].val << '\n'; }
Наконец, можно написать тривиальную программу:
main() // подсчет числа вхождений во входной // поток каждого слова { const MAX = 256; // больше длины самого длинного слова char buf[MAX]; assoc vec(512); while (cin>>buf) vec[buf]++; vec.print_all(); }
Опытные программисты могут заметить, что второй комментарий можно легко опровергнуть. Решить возникающую здесь проблему предлагается в упражнении §7.14 [20]. Дальнейшее развитие понятие ассоциативного массива получит в §8.8.
Функция operator[]() должна быть членом класса. Отсюда следует, что эквивалентность x[y] == y[x] может не выполняться, если x объект класса. Обычные отношения эквивалентности, справедливые для операций со встроенными типами, могут не выполняться для пользовательских типов (§7.2.2, см. также §7.9).
Инкремент и декремент
Если мы додумались до "хитрых указателей", то логично попробовать переопределить операции инкремента ++ и декремента -- , чтобы получить для классов те возможности, которые эти операции дают для встроенных типов. Такая задача особенно естественна и необходима, если ставится цель заменить тип обычных указателей на тип "хитрых указателей", для которого семантика остается прежней, но появляются некоторые действия динамического контроля. Пусть есть программа с распространенной ошибкой:
void f1(T a) // традиционное использование { T v[200]; T* p = &v[10]; p--; *p = a; // Приехали: `p' настроен вне массива, // и это не обнаружено ++p; *p = a; // нормально }
Естественно желание заменить указатель p на объект класса CheckedPtrToT, по которому косвенное обращение возможно только при условии, что он действительно указывает на объект. Применять инкремент и декремент к такому указателю будет можно только в том случае, что указатель настроен на объект в границах массива и в результате этих операций получится объект в границах того же массива:
class CheckedPtrToT { // ... };
void f2(T a) // вариант с контролем { T v[200]; CheckedPtrToT p(&v[0],v,200); p--; *p = a; // динамическая ошибка: // `p' вышел за границы массива ++p; *p = a; // нормально }
Инкремент и декремент являются единственными операциями в С++, которые можно использовать как постфиксные и префиксные операции. Следовательно, в определении класса CheckedPtrToT мы должны предусмотреть отдельные функции для префиксных и постфиксных операций инкремента и декремента:
class CheckedPtrToT { T* p; T* array; int size; public: // начальное значение `p' // связываем с массивом `a' размера `s' CheckedPtrToT(T* p, T* a, int s); // начальное значение `p' // связываем с одиночным объектом CheckedPtrToT(T* p);
T* operator++(); // префиксная T* operator++(int); // постфиксная
T* operator--(); // префиксная T* operator--(int); // постфиксная
T& operator*(); // префиксная };
Параметр типа int служит указанием, что функция будет вызываться для постфиксной операции. На самом деле этот параметр является искусственным и никогда не используется, а служит только для различия постфиксной и префиксной операции. Чтобы запомнить, какая версия функции operator++ используется как префиксная операция, достаточно помнить, что префиксной является версия без искусственного параметра, что верно и для всех других унарных арифметических и логических операций. Искусственный параметр используется только для "особых" постфиксных операций ++ и --.
С помощью класса CheckedPtrToT пример можно записать так:
void f3(T a) // вариант с контролем { T v[200]; CheckedPtrToT p(&v[0],v,200); p.operator--(1); p.operator*() = a; // динамическая ошибка: // `p' вышел за границы массива p.operator++(); p.operator*() = a; // нормально }
В упражнении §7.14 [19] предлагается завершить определение класса CheckedPtrToT, а другим упражнением (§9.10[2]) является преобразование его в шаблон типа, в котором для сообщений о динамических ошибках используются особые ситуации. Примеры использования операций ++ и -- для итераций можно найти в §8.8.
Конструкторы
Вместо того, чтобы описывать несколько функций, можно описать конструктор, который из параметра double создает complex:
class complex { // ... complex(double r) { re=r; im=0; } };
Этим определяется как получить complex, если задан double. Это традиционный способ расширения вещественной прямой до комплексной плоскости.
Конструктор с единственным параметром не обязательно вызывать явно:
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 operator+=(complex); complex operator*=(complex);
// ... };
Все операции над комплексными переменными и целыми константами с учетом этого описания становятся законными. Целая константа будет интерпретироваться как комплексное число с мнимой частью, равной нулю. Так, a=b*2 означает:
a = operator*(b, complex( double(2), double(0) ) )
Новые версии операций таких, как + , имеет смысл определять только, если практика покажет, что повышение эффективности за счет отказа от преобразований типа стоит того. Например, если выяснится, что операция умножения комплексной переменной на вещественную константу является критичной, то к множеству операций можно добавить operator*=(double):
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& operator+=(complex); complex& operator*=(complex); complex& operator*=(double);
// ... };
Операции присваивания типа *= и += могут быть очень полезными для работы с пользовательскими типами, поскольку обычно запись с ними короче, чем с их обычными "двойниками" * и + , а кроме того они могут повысить скорость выполнения программы за счет исключения временных переменных:
inline complex& complex::operator+=(complex a) { re += a.re; im += a.im; return *this; }
При использовании этой функции не требуется временной переменной для хранения результата, и она достаточно проста, чтобы транслятор мог "идеально" произвести подстановку тела. Такие простые операции как сложение комплексных тоже легко задать непосредственно:
inline complex operator+(complex a, complex b) { return complex(a.re+b.re, a.im+b.im); }
Здесь в операторе return используется конструктор, что дает транслятору ценную подсказку на предмет оптимизации. Но для более сложных типов и операций, например таких, как умножение матриц, результат нельзя задать как одно выражение, тогда операции * и + проще реализовать с помощью *= и += , и они будут легче поддаваться оптимизации:
matrix& matrix::operator*=(const matrix& a) { // ... return *this; }
matrix operator*(const matrix& a, const matrix& b) { matrix prod = a; prod *= b; return prod; }
Отметим, что в определенной подобным образом операции не нужных никаких особых прав доступа к классу, к которому она применяется, т.е. эта операция не должна быть другом или членом этого класса.
Пользовательское преобразование типа применяется только в том случае, если оно единственное(§7.3.3).
Построенный в результате явного или неявного вызова конструктора, объект является автоматическим, и уничтожается при первой возможности,- как правило сразу после выполнения оператора, в котором он был создан.
Косвенное обращение
Операцию косвенного обращения к члену -> можно определить как унарную постфиксную операцию. Это значит, если есть класс
class Ptr { // ... X* operator->(); };
объекты класса Ptr могут использоваться для доступа к членам класса X также, как для этой цели используются указатели:
void f(Ptr p) { p->m = 7; // (p.operator->())->m = 7 }
Превращение объекта p в указатель p.operator->() никак не зависит от члена m, на который он указывает. Именно по этой причине operator->() является унарной постфиксной операцией. Однако, мы не вводим новых синтаксических обозначений, так что имя члена по-прежнему должно идти после -> :
void g(Ptr p) { X* q1 = p->; // синтаксическая ошибка X* q2 = p.operator->(); // нормально }
Перегрузка операции -> прежде всего используется для создания "хитрых указателей", т.е. объектов, которые помимо использования как указатели позволяют проводить некоторые операции при каждом обращении к указуемому объекту с их помощью. Например, можно определить класс RecPtr для организации доступа к объектам класса Rec, хранимым на диске. Параметром конструктора RecPtr является имя, которое будет использоваться для поиска объекта на диске. При обращении к объекту с помощью функции RecPtr::operator->() он переписывается в основную память, а в конце работы деструктор RecPtr записывает измененный объект обратно на диск.
class RecPtr { Rec* in_core_address; const char* identifier; // ... public: RecPtr(const char* p) : identifier(p) { in_core_address = 0; } ~RecPtr() { write_to_disc(in_core_address,identifier); } Rec* operator->(); };
Rec* RecPtr::operator->() { if (in_core_address == 0) in_core_address = read_from_disc(identifier); return in_core_address; }
Использовать это можно так:
main(int argc, const char* argv) { for (int i = argc; i; i--) { RecPtr p(argv[i]); p->update(); } }
На самом деле, тип RecPtr должен определяться как шаблон типа (см. §8), а тип структуры Record будет его параметром. Кроме того, настоящая программа будет содержать обработку ошибок и взаимодействие с диском будет организовано не столь примитивно.
Для обычных указателей операция -> эквивалентна операциям, использующим * и []. Так, если описано
Y* p;
то выполняется соотношение
p->m == (*p).m == p[0].m
Как всегда, для определенных пользователем операций такие соотношения не гарантируются. Там, где все-таки такая эквивалентность требуется, ее можно обеспечить:
class X { Y* p; public: Y* operator->() { return p; } Y& operator*() { return *p; } Y& operator[](int i) { return p[i]; } };
Если в вашем классе определено более одной подобной операции, разумно будет обеспечить эквивалентность, точно так же, как разумно предусмотреть для простой переменной x некоторого класса, в котором есть операции ++, += = и +, чтобы операции ++x и x+=1 были эквивалентны x=x+1.
Перегрузка -> как и перегрузка [] может играть важную роль для целого класса настоящих программ, а не является просто экспериментом ради любопытства. Дело в том, что в программировании понятие косвенности является ключевым, а перегрузка -> дает ясный, прямой и эффективный способ представления этого понятия в программе. Есть другая точка зрения на операцию ->, как на средство задать в С++ ограниченный, но полезный вариант понятия делегирования (см. §12.2.8 и 13.9).
Литералы
Для классов нельзя определить литеральные значения, подобному тому как 1.2 и 12e3 являются литералами типа double. Однако, для интерпретации значений классов могут использоваться вместо функций-членов литералы основных типов. Общим средством для построения таких значений служат конструкторы с единственным параметром. Если конструктор достаточно простой и реализуется подстановкой, вполне разумно представлять его вызов как литерал. Например, с учетом описания класса complex в <complex.h> в выражении zz1*3+zz2*complex(1,2) произойдет два вызова функций, а не пять. Две операции * приведут к вызову функции, а операция + и вызовы конструктора для построения complex(3) и complex(1,2) будут реализованы подстановкой.
Неоднозначности
Присваивание или инициализация объекта класса X является законным, если присваиваемое значение имеет тип X, или если существует единственное преобразование его в значение типа X.
В некоторых случаях значение нужного типа строится с помощью повторных применений конструкторов или операций преобразования.
Это должно задаваться явным образом, допустимо неявное пользовательское преобразование только одного уровня вложенности. В некоторых случаях существует несколько способов построения значения нужного типа, но это является незаконным. Приведем пример:
class x { /* ... */ x(int); x(char*); }; class y { /* ... */ y(int); }; class z { /* ... */ z(x); };
x f(x); y f(y);
z g(z);
void k1() { f(1); // недопустимо, неоднозначность: f(x(1)) или f(y(1)) f(x(1)); f(y(1)); g("asdf"); // недопустимо, g(z(x("asdf"))) не используется }
Пользовательские преобразования типа рассматриваются только в том случае, когда без них нельзя однозначно выбрать вызываемую функцию:
class x { /* ... */ x(int); };
void h(double); void h(x);
void k2() { h(1); }
Вызов h(1) можно интерпретировать либо как h(double(1)), либо как h(x(1)), поэтому в силу требования однозначности его можно счесть незаконным. Но поскольку в первой интерпретации используется только стандартное преобразование, то по правилам, указанным в §4.6.6 и §R.13.2, выбирается оно.
Правила на преобразования типа не слишком просто сформулировать и реализовать, не обладают они и достаточной общностью. Рассмотрим требование единственности законного преобразования. Проще всего разрешить транслятору применять любое преобразование, которое он сумеет найти. Тогда для выяснения корректности выражения не нужно рассматривать все существующие преобразования. К сожалению, в таком случае поведение программы будет зависеть от того, какое именно преобразование найдено. В результате поведение программы будет зависеть от порядка описаний преобразований. Поскольку часто эти описания разбросаны по разным исходным файлам (созданным, возможно, разными программистами), то результат программы будет зависеть в каком порядке эти файлы сливаются в программу. С другой стороны, можно вообще запретить неявные преобразования, и это самое простое решение. Но результатом будет некачественный интерфейс, определяемый пользователем, или взрывной рост перегруженных функций и операций, что мы и видели на примере класса complex из предыдущего раздела.
При самом общем подходе учитываются все сведения о типах и рассматриваются все существующие преобразования.
Например, с учетом приведенных описаний в присваивании aa=f(1) можно разобраться с вызовом f(1), поскольку тип aa задает единственное преобразование. Если aa имеет тип x, то единственным преобразованием будет f(x(1)), поскольку только оно дает нужный для левой части тип x. Если aa имеет тип y, будет использоваться f(y(1)). При самом общем подходе удается разобраться и с вызовом g("asdf"), поскольку g(z(x("asdf))) является его единственной интерпретацией. Трудность этого подхода в том, что требуется доскональный разбор всего выражения, чтобы установить интерпретацию каждой операции и вызова функции. В результате трансляция замедляется, вычисление выражения может произойти странным образом и появляются загадочные сообщения об ошибках, когда транслятор учитывает определенные в библиотеках преобразования и т.д.
В результате транслятору приходится учитывать больше информации, чем известно самому программисту! Выбран подход, при котором проверка является строго восходящим процессом, когда в каждый момент рассматривается только одна операция с операндами, типы которых уже прошли проверку.
Требование строго восходящего разбора выражения предполагает, что тип возвращаемого значения не учитывается при разрешении перегрузки:
class quad { // ... public: quad(double); // ... };
quad operator+(quad,quad);
void f(double a1, double a2) { quad r1 = a1+a2; // сложение с двойной точностью quad r2 = quad(a1)+a2; // вынуждает использовать // операции с типами quad }
В проектировании языка делался расчет на строго восходящий разбор, поскольку он более понятный, а кроме того, не дело транслятора решать такие вопросы, какую точность для сложения желает программист.
Однако, надо отметить, что если определились типы обеих частей в присваивании и инициализации, то для их разрешения используется они оба:
class real { // ... public: operator double(); operator int(); // ... };
void g(real a) { double d = a; // d = a.double(); int i = a; // i = a.int();
d = a; // d = a.double(); i = a; // i = a.int(); }
В этом примере выражения все равно разбираются строго восходящим методом, когда в каждый момент рассматриваются только одна операция и типы ее операндов.
Операции преобразования
Конструктор удобно использовать для преобразования типа, но возможны нежелательные последствия:
Неявные преобразования от пользовательского типа к основному невозможны (поскольку основные типы не являются классами). Нельзя задать преобразование из нового типа в старый, не изменяя описания старого типа. Нельзя определить конструктор с одним параметром, не определив тем самым и преобразование типа.
Последнее не является большой проблемой, а первые две можно преодолеть, если определить операторную функцию преобразования для исходного типа. Функция-член X::operator T(), где T - имя типа, определяет преобразование типа X в T. Например, можно определить тип tiny (крошечный), значения которого находятся в диапазоне 0..63, и этот тип может в арифметических операциях практически свободно смешиваться с целыми:
class tiny { char v; void assign(int i) { if (i>63) { error("выход из диапазона"); v=i&~63; } v=i; } public: tiny(int i) { assign(i) } tiny(const tiny& t) { v = t.v; } tiny& operator=(const tiny& t) { v = t.v; return *this; } tiny& operator=(int i) { assign(i); return *this; } operator int() { return v; } };
Попадание в диапазон проверяется как при инициализации объекта tiny, так и в присваивании ему int. Один объект tiny можно присвоить другому без контроля диапазона. Для выполнения обычных операций с целыми для переменных типа tiny определяется функция tiny::operator int(), производящая неявное преобразование типа из tiny в int. Там, где требуется int, а задана переменная типа tiny, используется преобразованное к int значение:
void main() { tiny c1 = 2; tiny c2 = 62; tiny c3 = c2 -c1; // c3 = 60 tiny c4 = c3; // контроля диапазона нет (он не нужен) int i = c1 + c2; // i = 64 c1 = c2 + 2 * c1; // выход из диапазона: c1 = 0 (а не 66) c2 = c1 - i; // выход из диапазона: c2 = 0 c3 = c2; // контроля диапазона нет (он не нужен) }
Более полезным может оказаться вектор из объектов tiny, поскольку он позволяет экономить память. Чтобы такой тип было удобно использовать, можно воспользоваться операцией индексации [].
Пользовательские операции преобразования типа могут пригодиться для работы с типами, реализующими нестандартные представления чисел (арифметика с основанием 100, арифметика чисел с фиксированной точкой, представление в двоично-десятичной записи и т.д.). При этом обычно приходится переопределять такие операции, как + и *.
Особенно полезными функции преобразования типа оказываются для работы с такими структурами данных, для которых чтение (реализованное как операция преобразования) является тривиальным, а присваивание и инициализация существенно более сложные операции.
Функции преобразования нужны для типов istream и ostream, чтобы стали возможными, например, такие операторы:
while (cin>>x) cout<<x;
Операция ввода cin>>x возвращает значение istream&. Оно неявно преобразуется в значение, показывающее состояние потока cin, которое затем проверяется в операторе while (см. §10.3.2). Но все-таки определять неявное преобразование типа, при котором можно потерять преобразуемое значение, как правило, плохое решение.
Избыток таких операций может вызывать большое число неоднозначностей.
Транслятор обнаруживает эти неоднозначности, но разрешить их может быть совсем непросто. Возможно вначале лучше для преобразований использовать поименованные функции, например, X::intof(), и только после того, как такую функцию как следуют опробуют, и явное преобразование типа будет сочтено неэлегантным решением, можно заменить операторной функцией преобразования X::operator int().
Операторные функции
Можно описать функции, определяющие интерпретацию следующих операций:
+ - * / % ^ & | ~ ! = < > += -= *= /= %= ^= &= |= << >> >>= <<= == != <= >= && || ++ -- ->* , -> [] () new delete
Последние пять операций означают: косвенное обращение (§7.9), индексацию (§7.7), вызов функции (§7.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 инициализаторы в этом примере являются эквивалентными.
Пользовательские операции преобразования типа
Описанная во введении реализация комплексного числа является слишком ограниченной, чтобы удовлетворить кого-нибудь, и ее надо расширить. Делается простым повторением описаний того же вида, что уже были применены:
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);
// ... };
Имея такое определение комплексного числа, можно писать:
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; }
Все-таки утомительно, как мы это только что делали для operator*() писать для каждой комбинации complex и double свою функцию. Более того, разумные средства для комплексной арифметики должны предоставлять десятки таких функций (посмотрите, например, как описан тип complex в <complex.h>).
Предопределенные свойства операций
Используется только несколько предположений о свойствах пользовательских операций. В частности, operator=, operator[], operator() и operator-> должны быть нестатическими функциями-членами. Этим обеспечивается то, что первый операнд этих операций является адресом.
Для некоторых встроенных операций их интерпретация определяется как комбинация других операций, выполняемых над теми же операндами.
Так, если a типа int, то ++a означает a+=1, что в свою очередь означает a=a+1. Такие соотношения не сохраняются для пользовательских операций, если только пользователь специально не определил их с такой целью. Так, определение operator+=() для типа complex нельзя вывести из определений complex::operator+() и complex operator=().
По исторической случайности оказалось, что операции = (присваивание), &(взятие адреса) и , (операция запятая) обладают предопределенными свойствами для объектов классов. Но можно закрыть от произвольного пользователя эти свойства, если описать эти операции как частные:
class X { // ... private: void operator=(const X&); void operator&(); void operator,(const X&); // ... };
void f(X a, X b) { a= b; // ошибка: операция = частная &a; // ошибка: операция & частная a,b // ошибка: операция , частная }
С другой стороны, можно наоборот придать с помощью соответствующих определений этим операциям иное значение.
Предостережения
Как и всякое другое языковое средство, перегрузка операций может использоваться разумно и неразумно. В частности, возможностью придавать новый смысл обычным операциям можно воспользоваться так, что программа будет совершенно непостижимой. Представьте, каково будет читателю, если в своей программе вы переопределили операцию + так, чтобы она обозначала вычитание. Описанный здесь механизм перегрузки будет защищать программиста и пользователя от таких безрассудств. Поэтому программист не может изменить ни смысл операций над основными типами данных, такими, как int, ни синтаксис выражений и приоритеты операций для них.
По всей видимости перегрузку операций имеет смысл использовать для подражания традиционному использованию операций. Запись с обычным вызовом функции можно использовать в тех случаях, когда традиционной записи с базовой операцией не существует, или, когда набор операций, которые допускают перегрузку, не достаточен, чтобы записать с его помощью нужные действия.
Присваивание и инициализация
Рассмотрим простой строковый класс string:
struct string { char* p; int size; // размер вектора, на который указывает p
string(int size) { p = new char[size=sz]; } ~string() { delete p; } };
Строка - это структура данных, содержащая указатель на вектор символов и размер этого вектора. Вектор создается конструктором и удаляется деструктором. Но как мы видели в §5.5.1 здесь могут возникнуть проблемы:
void f() { string s1(10); string s2(20) s1 = s2; }
Здесь будут размещены два символьных вектора, но в результате присваивания s1 = s2 указатель на один из них будет уничтожен, и заменится копией второго. По выходе из f() будет вызван для s1 и s2 деструктор, который дважды удалит один и тот же вектор, результаты чего по всей видимости будут плачевны. Для решения этой проблемы нужно определить соответствующее присваивание объектов типа string:
struct string { char* p; int size; // размер вектора, на который указывает p
string(int size) { p = new char[size=sz]; } ~string() { delete p; } string& operator=(const string&); };
string& string::operator=(const string& a) { if (this !=&a) { // опасно, когда s=s delete p; p = new char[size=a.size]; strcpy(p,a.p); } return *this; }
При таком определении string предыдущий пример пройдет как задумано. Но после небольшого изменения в f() проблема возникает снова, но в ином обличии:
void f() { string s1(10); string s2 = s1; // инициализация, а не присваивание }
Теперь только один объект типа string строится конструктором string::string(int), а уничтожаться будет две строки. Дело в том, что пользовательская операция присваивания не применяется к неинициализированному объекту. Достаточно взглянуть на функцию string::operator(), чтобы понять причину этого: указатель p будет тогда иметь неопределенное, по сути случайное значение.
Как правило, в операции присваивания предполагается, что ее параметры проинициализированы. Для инициализации типа той, что приведена в этом примере это не так по определению. Следовательно, чтобы справиться с инициализацией нужна похожая, но своя функция:
struct string { char* p; int size; // размер вектора, на который указывает p
string(int size) { p = new char[size=sz]; } ~string() { delete p; } string& operator=(const string&); string(const string&); };
string::string(const string& a) { p=new char[size=sz]; strcpy(p,a.p); }
Инициализация объекта типа X происходит с помощью конструктора X(const X&). Мы не перестаем повторять, что присваивание и инициализация являются разными операциями. Особенно это важно в тех случаях, когда определен деструктор. Если в классе X есть нетривиальный деструктор, например, производящий освобождение объекта в свободной памяти, вероятнее всего, в этом классе потребуется полный набор функций, чтобы избежать копирования объектов по членам:
class X { // ... X(something); // конструктор, создающий объект X(const X&); // конструктор копирования operator=(const X&); // присваивание: // удаление и копирование ~X(); // деструктор, удаляющий объект };
Есть еще два случая, когда приходится копировать объект: передача параметра функции и возврат ею значения. При передаче параметра неинициализированная переменная, т.е. формальный параметр инициализируется. Семантика этой операции идентична другим видам инициализации. Тоже происходит и при возврате функцией значения, хотя этот случай не такой очевидный. В обоих случаях используется конструктор копирования:
string g(string arg) { return arg; }
main() { string s = "asdf"; s = g(s); }
Очевидно, после вызова g() значение s должно быть "asdf". Не трудно записать в параметр s копию значения s, для этого надо вызвать конструктор копирования для string. Для получения еще одной копии значения s по выходе из g() нужен еще один вызов конструктора string(const string&). На этот раз инициализируется временная переменная, которая затем присваивается s. Для оптимизации одну, но не обе, из подобных операций копирования можно убрать. Естественно, временные переменные, используемые для таких целей, уничтожаются надлежащим образом деструктором string::~string() (см. §R.12.2).
Если в классе X операция присваивания X::operator=(const X&) и конструктор копирования X::X(const X&) явно не заданы программистом, недостающие операции будут созданы транслятором. Эти созданные функции будут копировать по членам для всех членов класса X. Если члены принимают простые значения, как в случае комплексных чисел, это, то, что нужно, и созданные функции превратятся в простое и оптимальное поразрядное копирование. Если для самих членов определены пользовательские операции копирования, они и будут вызываться соответствующим образом:
class Record { string name, address, profession; // ... };
void f(Record& r1) { Record r2 = r1; }
Здесь для копирования каждого члена типа string из объекта r1 будет вызываться string::operator=(const string&). В нашем первом и неполноценном варианте строковый класс имеет член-указатель и деструктор. Поэтому стандартное копирование по членам для него почти наверняка неверно. Транслятор может предупреждать о таких ситуациях.
Строковый класс
Теперь можно привести более осмысленный вариант класса string. В нем подсчитывается число ссылок на строку, чтобы минимизировать копирование, и используются как константы стандартные строки C++.
#include <iostream.h> #include <string.h>
class string { struct srep { char* s; // указатель на строку int n; // счетчик числа ссылок srep() { n = 1; } }; srep *p;
public: string(const char *); // string x = "abc" string(); // string x; string(const string &); // string x = string ... string& operator=(const char *); string& operator=(const string &); ~string(); char& operator[](int i);
friend ostream& operator<<(ostream&, const string&); friend istream& operator>>(istream&, string&);
friend int operator==(const string &x, const char *s) { return strcmp(x.p->s,s) == 0; }
friend int operator==(const string &x, const string &y) { return strcmp(x.p->s,y.p->s) == 0; }
friend int operator!=(const string &x, const char *s) { return strcmp(x.p->s,s) != 0; }
friend int operator!=(const string &x, const string &y) { return strcmp(x.p->s,y.p->s) != 0; } };
Конструкторы и деструкторы тривиальны:
string::string() { p = new srep; p->s = 0; }
string::string(const string& x) { x.p->n++; p = x.p; }
string::string(const char* s) { p = new srep; p->s = new char[ strlen(s)+1 ]; strcpy(p->s, s); }
string::~string() { if (--p->n == 0) { delete[] p->s; delete p; } }
Как и всегда операции присваивания похожи на конструкторы. В них нужно позаботиться об удалении первого операнда, задающего левую часть присваивания:
string& string::operator=(const char* s) { if (p->n > 1) { // отсоединяемся от старой строки p->n--; p = new srep; } else // освобождаем строку со старым значением delete[] p->s;
p->s = new char[ strlen(s)+1 ]; strcpy(p->s, s); return *this; }
string& string::operator=(const string& x) { x.p->n++; // защита от случая ``st = st'' if (--p->n == 0) { delete[] p->s; delete p } p = x.p; return *this; }
Операция вывода показывает как используется счетчик числа ссылок. Она сопровождает как эхо каждую введенную строку (ввод происходит с помощью операции << , приведенной ниже):
ostream& operator<<(ostream& s, const string& x) { return s << x.p->s << " [" << x.p->n << "]\n"; }
Операция ввода происходит с помощью стандартной функции ввода символьной строки (§10.3.1):
istream& operator>>(istream& s, string& x) { char buf[256]; s >> buf; // ненадежно: возможно переполнение buf // правильное решение см. в §10.3.1 x = buf; cout << "echo: " << x << '\n'; return s; }
Операция индексации нужна для доступа к отдельным символам. Индекс контролируется:
void error(const char* p) { cerr << p << '\n'; exit(1); }
char& string::operator[](int i) { if (i<0 || strlen(p->s)<i) error("недопустимое значение индекса"); return p->s[i]; }
В основной программе просто даны несколько примеров применения строковых операций. Слова из входного потока читаются в строки, а затем строки печатаются. Это продолжается до тех пор, пока не будет обнаружена строка done, или закончатся строки для записи слов, или закончится входной поток. Затем печатаются все строки в обратном порядке и программа завершается.
int main() { string x[100]; int n;
cout << " здесь начало \n";
for ( n = 0; cin>>x[n]; n++) { if (n==100) { error("слишком много слов"); return 99; } string y; cout << (y = x[n]); if (y == "done") break;
} cout << "теперь мы идем по словам в обратном порядке \n"; for (int i=n-1; 0<=i; i--) cout << x[i]; return 0; }
Упражнения
(*2) Определите итератор для класса string. Определите операцию конкатенации + и операцию += , значащую "добавить в конец строки". Какие еще операции вы хотели бы и смогли определить для этого класса? (*1.5) Определите для строкового класса операцию выделения подстроки с помощью перегрузки (). (*3) Определите класс string таким образом, чтобы операцию выделения подстроки можно было применять к левой части присваивания. Вначале напишите вариант, в котором строку можно присваивать подстроке той же длины, а затем вариант с различными длинами строк. (*2) Разработайте класс string таким образом, чтобы объекты его трактовались при передаче параметров и присваивании как значения, т.е. чтобы в классе string копировались сами представления строк, а не только управляющие структуры. (*3) Измените класс string из предыдущего упражнения так, чтобы строки копировались только при необходимости. Это значит, что нужно хранить одно общее представления двух одинаковых строк до тех пор, пока одна из них не изменится. Не пытайтесь задать операцию выделения подстроки, которую одновременно можно применять и к левой части присваивания. (*4) Определите класс string, обладающий перечисленными в предыдущих упражнениях свойствами: объекты его трактуются как значения, копирование является отложенным (т.е. происходит только при необходимости) и операцию выделения подстроки можно применять к левой части присваивания. (*2) Какие преобразования типа используются в выражениях следующей программы?
struct X { int i; X(int); operator+(int); };
struct Y { int i; Y(X); operator+(X); operator int(); };
extern X operator*(X,Y); extern int f(X);
X x = 1; Y y = x; int i = 2;
int main() { i + 10; y + 10; y + 10 * y; x + y + i; x * X +i; f(7); f(y); y + y; 106 + y; }
Определите X и Y как целые типы. Измените программу так, чтобы ее можно было выполнить и она напечатала значения всех правильных выражений. (*2) Определите класс INT, который будет эквивалентен типу int. Подсказка: определите функцию INT::operator int().(*1) Определите класс RINT, который будет эквивалентен типу int, за исключением того, что допустимыми будут только операции: + (унарный и бинарный), - (унарный и бинарный), *, / и %. Подсказка: не надо определять RINT::operator int(). (*3) Определите класс LINT, эквивалентный классу RINT, но в нем для представления целого должно использоваться не менее 64 разрядов.(*4) Определите класс, реализующий арифметику с произвольной точностью. Подсказка: Придется использовать память так, как это делается в классе string. (*2) Напишите программу, в которой благодаря макрокомандам и перегрузке будет невозможно разобраться. Совет: определите для типа INT + как -, и наоборот; с помощью макроопределения задайте int как INT. Кроме того, большую путаницу можно создать, переопределяя широко известные функции, и используя параметры типа ссылки и задавая вводящие в заблуждение комментарии.(*3) Обменяйтесь решениями упражнения [12] с вашим другом. Попробуйте понять, что делает его программа, не запуская ее. Если вы сделаете это упражнение, вам станет ясно, чего надо избегать.(*2) Перепишите примеры с классами complex (§7.3), tiny (§7.3.2) и string (§7.11), не используя дружественные функции. Используйте только функции-члены. Проверьте новые версии этих классов. Сравните их с версиями, в которых используются дружественные функции. Обратитесь к упражнению 5.3.(*2) Определите тип vec4 как вектор из четырех чисел с плавающей точкой. Определите для него функцию operator[]. Для комбинаций векторов и чисел с плавающей точкой определите операции: +, -, *, /, =, +=, -=, *= и /=.(*3) Определите класс mat4 как вектор из четырех элементов типа vec4. Определите для него функцию operator[], возвращающую vec4. Определите для этого типа обычные операции с матрицами. Определите в mat4 функцию, производящую преобразование Гаусса с матрицей.(*2) Определите класс vector, аналогичный классу vec4, но здесь размер вектора должен задаваться как параметр конструктора vector::vector(int).(*3) Определите класс matrix, аналогичный классу mat4, но здесь размерности матрицы должны задаваться как параметры конструктора matrix::matrix(int,int).(*3) Завершите определение класса CheckedPtrToT из §7.10 и проверьте его. Чтобы определение этого класса было полным, необходимо определить, по крайней мере, такие операции: *, ->, =, ++ и --. Не выдавайте динамическую ошибку, пока действительно не произойдет обращение по указателю с неопределенным значением.(*1.5) Перепишите пример с программой подсчета слов из §7.7 так, чтобы в ней не было заранее заданной максимальной длины слова.
я выбираю слово, оно значит
Если я выбираю слово, оно значит только то, что я решу, ни больше и ни меньше.
Обычно в программах используются объекты, являющиеся конкретным представлением абстрактных понятий. Например, в С++ тип данных 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.
Вызов функции
Вызов функции, т.е. конструкцию выражение(список-выражений), можно рассматривать как бинарную операцию, в которой выражение является левым операндом, а список-выражений - правым. Операцию вызова можно перегружать как и другие операции. В функции operator()() список фактических параметров вычисляется и проверяется по типам согласно обычным правилам передачи параметров. Перегрузка операции вызова имеет смысл прежде всего для типов, с которыми возможна только одна операция, а также для тех типов, одна из операций над которыми имеет настолько важное значение, что все остальные в большинстве случаев можно не учитывать.
Мы не дали определения итератора для ассоциативного массива типа assoc. Для этой цели можно определить специальный класс assoc_iterator, задача которого выдавать элементы из assoc в некотором порядке. В итераторе необходимо иметь доступ к данным, хранимым в assoc, поэтому он должен быть описан как friend:
class assoc { friend class assoc_iterator; pair* vec; int max; int free; public: assoc(int); int& operator[](const char*); };
Итератор можно определить так:
class assoc_iterator { const assoc* cs; // массив assoc int i; // текущий индекс public: assoc_iterator(const assoc& s) { cs = &s; i = 0; } pair* operator()() { return (i<cs->free)? &cs->vec[i++] : 0; } };
Массив assoc объекта assoc_iterator нужно инициализировать, и при каждом обращении к нему с помощью операторной функции () будет возвращаться указатель на новую пару (структура pair) из этого массива. При достижении конца массива возвращается 0:
main() // подсчет числа вхождений во входной // поток каждого слова { const MAX = 256; // больше длины самого длинного слова char buf[MAX]; assoc vec(512); while (cin>>buf) vec[buf]++; assoc_iterator next(vec); pair* p; while ( p = next(vec) ) cout << p->name << ": " << p->val << '\n'; }
Итератор подобного вида имеет преимущество перед набором функций, решающим ту же задачу: итератор может иметь собственные частные данные, в которых можно хранить информацию о ходе итерации. Обычно важно и то, что можно одновременно запустить сразу несколько итераторов одного типа.
Конечно, использование объектов для представления итераторов непосредственно никак не связано с перегрузкой операций. Одни предпочитают использовать тип итератора с такими операциями, как first(), next() и last(), другим больше нравится перегрузка операции ++ , которая позволяет получить итератор, используемый как указатель (см. §8.8). Кроме того, операторная функция operator() активно используется для выделения подстрок и индексации многомерных массивов.
Функция operator() должна быть функцией-членом.
Ассоциативный массив
Из всех универсальных невстроенных типов самым полезным, по всей видимости, является ассоциативный массив. Его часто называют таблицей (map), а иногда словарем, и он хранит пары значений. Имея одно из значений, называемое ключом, можно получить доступ к другому, называемому просто значением. Ассоциативный массив можно представлять как массив, в котором индекс не обязан быть целым:
template<class K, class V> class Map { // ... public: V& operator[](const K&); // найти V, соответствующее K // и вернуть ссылку на него // ... };
Здесь ключ типа K обозначает значение типа V. Предполагается, что ключи можно сравнивать с помощью операций == и <, так что массив можно хранить в упорядоченном виде. Отметим, что класс Map отличается от типа assoc из §7.8 тем, что для него нужна операция "меньше чем", а не функция хэширования.
Приведем простую программу подсчета слов, в которой используются шаблон Map и тип String:
#include <String.h> #include <iostream.h> #include "Map.h"
int main() { Map<String,int> count; String word;
while (cin >> word) count[word]++;
for (Mapiter<String,int> p = count.first(); p; p++) cout << p.value() << '\t' << p.key() << '\n';
return 0; }
Мы используем тип String для того, чтобы не беспокоиться о выделении памяти и переполнении ее, о чем приходится помнить, используя тип char*. Итератор Mapiter нужен для выбора по порядку всех значений массива. Итерация в Mapiter задается как имитация работы с указателями. Если входной поток имеет вид
It was new. It was singular. It was simple. It must succeed.
программа выдаст
4 It 1 must 1 new. 1 simple. 1 singular. 1 succeed. 3 was.
Конечно, определить ассоциативный массив можно многими способами, а, имея определение Map и связанного с ним класса итератора, мы можем предложить много способов для их реализации. Здесь выбран тривиальный способ реализации. Используется линейный поиск, который не подходит для больших массивов. Естественно, рассчитанная на коммерческое применение реализация будет создаваться, исходя из требований быстрого поиска и компактности представления (см. упражнение 4 из §8.9).
Мы используем список с двойной связью Link:
template<class K, class V> class Map; template<class K, class V> class Mapiter;
template<class K, class V> class Link { friend class Map<K,V>; friend class Mapiter<K,V>; private: const K key; V value;
Link* pre; Link* suc;
Link(const K& k, const V& v) : key(k), value(v) { } ~Link() { delete suc; } // рекурсивное удаление всех // объектов в списке };
Каждый объект Link содержит пару (ключ, значение). Классы описаны в Link как друзья, и это гарантирует, что объекты Link можно создавать, работать с ними и уничтожать только с помощью соответствующих классов итератора и Map. Обратите внимание на предварительные описания шаблонных классов Map и Mapiter.
Шаблон Map можно определить так:
template<class K, class V> class Map { friend class Mapiter<K,V>; Link<K,V>* head; Link<K,V>* current; V def_val; K def_key; int sz;
void find(const K&); void init() { sz = 0; head = 0; current = 0; }
public:
Map() { init(); } Map(const K& k, const V& d) : def_key(k), def_val(d) { init(); } ~Map() { delete head; } // рекурсивное удаление // всех объектов в списке Map(const Map&); Map& operator= (const Map&);
V& operator[] (const K&);
int size() const { return sz; } void clear() { delete head; init(); } void remove(const K& k);
// функции для итерации
Mapiter<K,V> element(const K& k) { (void) operator[](k); // сделать k текущим элементом return Mapiter<K,V>(this,current); } Mapiter<K,V> first(); Mapiter<K,V> last(); };
Элементы хранятся в упорядоченном списке с двойной связью. Для простоты ничего не делается для ускорения поиска (см. упражнение 4 из §8.9). Ключевой здесь является функция operator[]():
template<class K, class V> V& Map<K,V>::operator[] (const K& k) { if (head == 0) { current = head = new Link<K,V>(k,def_val); current->pre = current->suc = 0; return current->value; }
Link<K,V>* p = head; for (;;) { if (p->key == k) { // найдено current = p; return current->value; }
if (k < p->key) { // вставить перед p (в начало) current = new Link<K,V>(k,def_val); current->pre = p->pre; current->suc = p; if (p == head) // текущий элемент становится начальным head = current; else p->pre->suc = current; p->pre = current; return current->value; }
Link<K,V>* s = p->suc; if (s == 0) { // вставить после p (в конец) current = new Link<K,V>(k,def_val); current->pre = p; current->suc = 0; p->suc = current; return current->value; } p = s; } }
Операция индексации возвращает ссылку на значение, которое соответствует заданному как параметр ключу. Если такое значение не найдено, возвращается новый элемент со стандартным значением. Это позволяет использовать операцию индексации в левой части присваивания. Стандартные значения для ключей и значений устанавливаются конструкторами Map. В операции индексации определяется значение current, используемое итераторами.
Реализация остальных функций-членов оставлена в качестве упражнения:
template<class K, class V> void Map<K,V>::remove(const K& k) { // см. упражнение 2 из §8.10 }
template<class K, class V> Map<K,V>::Map(const Map<K,V>& m) { // копирование таблицы Map и всех ее элементов }
template<class K, class V> Map& Map<K,V>::operator=(const Map<K,V>& m) { // копирование таблицы Map и всех ее элементов }
Теперь нам осталось только определить итерацию. В классе Map есть функции-члены first(), last() и element(const K&), которые возвращают итератор, установленный соответственно на первый, последний или задаваемый ключом-параметром элемент. Сделать это можно, поскольку элементы хранятся в упорядоченном по ключам виде.
Итератор Mapiter для Map определяется так:
template<class K, class V> class Mapiter { friend class Map<K,V>;
Map<K,V>* m; Link<K,V>* p;
Mapiter(Map<K,V>* mm, Link<K,V>* pp) { m = mm; p = pp; } public: Mapiter() { m = 0; p = 0; } Mapiter(Map<K,V>& mm);
operator void*() { return p; }
const K& key(); V& value();
Mapiter& operator--(); // префиксная void operator--(int); // постфиксная Mapiter& operator++(); // префиксная void operator++(int); // постфиксная };
После позиционирования итератора функции key() и value() из Mapiter выдают ключ и значение того элемента, на который установлен итератор.
template<class K, class V> const K& Mapiter<K,V>::key() { if (p) return p->key; else return m->def_key; }
template<class K, class V> V& Mapiter<K,V>::value() { if (p) return p->value; else return m->def_val; }
По аналогии с указателями определены операции ++ и -- для продвижения по элементам Map вперед и назад:
Mapiter<K,V>& Mapiter<K,V>::operator--() //префиксный декремент { if (p) p = p->pre; return *this; }
void Mapiter<K,V>::operator--(int) // постфиксный декремент { if (p) p = p->pre; }
Mapiter<K,V>& Mapiter<K,V>::operator++() // префиксный инкремент { if (p) p = p->suc; return *this; }
void Mapiter<K,V>::operator++(int) // постфиксный инкремент { if (p) p = p->suc; }
Постфиксные операции определены так, что они не возвращают никакого значения. Дело в том, что затраты на создание и передачу нового объекта Mapiter на каждом шаге итерации значительны, а польза от него будет не велика.
Объект Mapiter можно инициализировать так, чтобы он был установлен на начало Map:
template<class K, class V> Mapiter<K,V>::Mapiter(Map<K,V>& mm) { m == &mm; p = m->head; }
Операция преобразования operator void*() возвращает нуль, если итератор не установлен на элемент Map, и ненулевое значение иначе. Значит можно проверять итератор iter, например, так:
void f(Mapiter<const char*, Shape*>& iter) { // ... if (iter) { // установлен на элемент таблицы } else { // не установлен на элемент таблицы }
// ... }
Аналогичный прием используется для контроля потоковых операций ввода-вывода в §10.3.2.
Если итератор не установлен на элемент таблицы, его функции key() и value() возвращают ссылки на стандартные объекты.
Если после всех этих определений вы забыли их назначение, можно привести еще одну небольшую программу, использующую таблицу Map. Пусть входной поток является списком пар значений следующего вида:
hammer 2 nail 100 saw 3 saw 4 hammer 7 nail 1000 nail 250
Нужно отсортировать список так, чтобы значения, соответствующие одному предмету, складывались, и напечатать получившийся список вместе с итоговым значением:
hammer 9 nail 1350 saw 7 ------------------- total 1366
Вначале напишем функцию, которая читает входные строки и заносит предметы с их количеством в таблицу. Ключом в этой таблице является первое слово строки:
template<class K, class V> void readlines(Map<K,V>&key) { K word; while (cin >> word) { V val = 0; if (cin >> val) key[word] +=val; else return; } }
Теперь можно написать простую программу, вызывающую функцию readlines() и печатающую получившуюся таблицу:
main() { Map<String,int> tbl("nil",0); readlines(tbl);
int total = 0; for (Mapiter<String,int> p(tbl); p; ++p) { int val = p.value(); total +=val; cout << p.key() << '\t' << val << '\n'; }
cout << "--------------------\n"; cout << "total\t" << total << '\n'; }
Итерация
В классе slist_base нет функций для просмотра списка, можно только вставлять и удалять элементы. Однако, в нем описывается как друг класс slist_base_iter, поэтому можно определить подходящий для списка итератор. Вот один из возможных, заданный в том стиле, какой был показан в §7.8:
class slist_base_iter { slink* ce; // текущий элемент slist_base* cs; // текущий список public: inline slist_base_iter(slist_base& s); inline slink* operator()() };
slist_base_iter::slist_base_iter(slist_base& s) { cs = &s; ce = cs->last; }
slink* slist_base_iter::operator()() // возвращает 0, когда итерация кончается { slink* ret = ce ? (ce=ce->next) : 0; if (ce == cs->last) ce = 0; return ret; }
Исходя из этих определений, легко получить итераторы для Slist и Islist. Сначала надо определить дружественные классы для итераторов по соответствующим контейнерным классам:
template<class T> class Islist_iter;
template<class T> class Islist { friend class Islist_iter<T>; // ... };
template<class T> class Slist_iter;
template<class T> class Slist { friend class Slist_iter<T>; // ... };
Обратите внимание, что имена итераторов появляются без определения их шаблонного класса. Это способ определения в условиях взаимной зависимости шаблонов типа.
Теперь можно определить сами итераторы:
template<class T> class Islist_iter : private slist_base_iter { public: Islist_iter(Islist<T>& s) : slist_base_iter(s) { }
T* operator()() { return (T*) slist_base_iter::operator()(); } };
template<class T> class Slist_iter : private slist_base_iter { public: Slist_iter(Slist<T>& s) : slist_base_iter(s) { } inline T* operator()(); };
T* Slist_iter::operator()() { return ((Tlink<T>*) slist_base_iter::operator()())->info; }
Заметьте, что мы опять использовали прием, когда из одного базового класса строится семейство производных классов (а именно, шаблонный класс). Мы используем наследование, чтобы выразить общность классов и избежать ненужного дублирования функций. Трудно переоценить стремление избежать дублирования функций при реализации таких простых и часто используемых классов как списки и итераторы. Пользоваться этими итераторами можно так:
void f(name* p) { Islist<name> lst1; Slist<name> lst2;
lst1.insert(p); lst2.insert(p); // ...
Islist_iter<name> iter1(lst1); const name* p; while (p=iter1()) { list_iter<name> iter2(lst1); const name* q; while (q=iter2()) { if (p == q) cout << "найден" << *p << '\n'; } } }
Есть несколько способов задать итератор для контейнерного класса. Разработчик программы или библиотеки должен выбрать один из них и придерживаться его. Приведенный способ может показаться слишком хитрым. В более простом варианте можно было просто переименовать operator()() как next(). В обоих вариантах предполагается взаимосвязь между контейнерным классом и итератором для него, так что можно при выполнении итератора обработать случаи, когда элементы добавляются или удаляются из контейнера. Этот и некоторые другие способы задания итераторов были бы невозможны, если бы итератор зависел от функции пользователя, в которой есть указатели на элементы из контейнера. Как правило, контейнер или его итераторы реализуют понятие "установить итерацию на начало" и понятие "текущего элемента".
Если понятие текущего элемента предоставляет не итератор, а сам контейнер, итерация происходит в принудительном порядке по отношению к контейнеру аналогично тому, как поля связи принудительно хранятся в объектах из контейнера. Значит трудно одновременно вести две итерации для одного контейнера, но расходы на память и время при такой организации итерации близки к оптимальным. Приведем пример:
class slist_base { // ... slink* last; // last->next голова списка slink* current; // текущий элемент public: // ... slink* head() { return last?last->next:0; } slink* current() { return current; } void set_current(slink* p) { current = p; } slink* first() { set_current(head()); return current; } slink* next(); slink* prev(); };
Подобно тому, как в целях эффективности и компактности программы можно использовать для одного объекта как список с принудительной связью, так и список без нее, для одного контейнера можно использовать принудительную и непринудительную итерацию:
void f(Islist<name>& ilst) // медленный поиск имен-дубликатов { list_iter<name> slow(ilst); // используется итератор name* p; while (p = slow()) { ilst.set_current(p); // рассчитываем на текущий элемент name* q; while (q = ilst.next()) if (strcmp(p->string,q->string) == 0) cout << "дубликат" << p << '\n'; } }
Еще один вид итераторов показан в §8.8.
Неявная передача операций
В примере из предыдущего раздела объекты Comparator на самом деле никак не использовались в вычислениях. Это просто "искусственные" параметры, нужные для правильного контроля типов. Введение таких параметров достаточно общий и полезный прием, хотя и не слишком красивый. Однако, если объект используется только для передачи операции (как и было в нашем случае), т.е. в вызываемой функции не используется ни значение, ни адрес объекта, то можно вместо этого передавать операцию неявно:
template<class T> void sort(Vector<T>& v) { unsigned n = v.size();
for (int i=0; i<n-1; i++) for (int j=n-1; i<j; j--) if (Comparator<T>::lessthan(v[j],v[j-1])) { // меняем местами v[j] и v[j-1] T temp = v[j]; v[j] = v[j-1]; v[j-1] = temp; } }
В результате мы приходим к первоначальному варианту использования sort():
void f(Vector<int>& vi, Vector<String>& vc, Vector<int>& vi2, Vector<char*>& vs) {
sort(vi); // sort(Vector<int>&); sort(vc); // sort(Vector<String>&); sort(vi2); // sort(Vector<int>&); sort(vs); // sort(Vector<char*>&); }
Основное преимущество этого варианта, как и двух предыдущих, по сравнению с исходным вариантом в том, что часть программы, занятая собственно сортировкой, отделена от частей, в которых находятся такие операции, работающие с элементами, как, например lessthan. Необходимость подобного разделения растет с ростом программы, и особенный интерес это разделение представляет при проектировании библиотек. Здесь создатель библиотеки не может знать типы параметров шаблона, а пользователи не знают (или не хотят знать) специфику используемых в шаблоне алгоритмов. В частности, если бы в функции sort() использовался более сложный, оптимизированный и рассчитанный на коммерческое применение алгоритм, пользователь не очень бы стремился написать свою особую версию для типа char*, как это было сделано в §8.4.1. Хотя реализация класса Comparator для специального случая char* тривиальна и может использоваться и в других ситуациях.
Параметры шаблона типа
Параметр шаблона типа не обязательно должен быть именем типа (см. §R.14.2). Помимо имен типов можно задавать строки, имена функций и выражения-константы. Иногда бывает нужно задать как параметр целое:
template<class T, int sz> class buffer { T v[sz]; // буфер объектов произвольного типа // ... };
void f() { buffer<char,128> buf1; buffer<complex,20> buf2; // ... }
Мы сделали sz параметром шаблона buffer, а не его объектов, и это означает, что размер буфера должен быть известен на стадии трансляции, чтобы его объекты было можно размещать, не используя свободную память. Благодаря этому свойству такие шаблоны как buffer полезны для реализации контейнерных классов, поскольку для последних первостепенным фактором, определяющим их эффективность, является возможность размещать их вне свободной памяти. Например, если в реализации класса string короткие строки размещаются в стеке, это дает существенный выигрыш для программы, поскольку в большинстве задач практически все строки очень короткие. Для реализации таких типов как раз и может пригодиться шаблон buffer.
Каждый параметр шаблона типа для функции должен влиять на тип функции, и это влияние выражается в том, что он участвует по крайней мере в одном из типов формальных параметров функций, создаваемых по шаблону. Это нужно для того, чтобы функции можно было выбирать и создавать, основываясь только на их параметрах:
template<class T> void f1(T); // нормально template<class T> void f2(T*); // нормально template<class T> T f3(int); // ошибка template<int i> void f4(int[][i]); // ошибка template<int i> void f5(int = i); // ошибка template<class T, class C> void f6(T); // ошибка template<class T> void f7(const T&, complex); // нормально template<class T> void f8(Vector< List<T> >); // нормально
Здесь все ошибки вызваны тем, что параметр-тип шаблона никак не влияет на формальные параметры функций.
Подобного ограничения нет в шаблонах типа для классов. Дело в том, что параметр для такого шаблона нужно указывать всякий раз, когда описывается объект шаблонного класса. С другой стороны, для шаблонных классов возникает вопрос: когда два созданных по шаблону типа можно считать одинаковыми? Два имени шаблонного класса обозначают один и тот же класс, если совпадают имена их шаблонов, а используемые в этих именах параметры имеют одинаковые значения (с учетом возможных определений typedef, вычисления выражений-констант и т.д.). Вернемся к шаблону buffer:
template<class T, int sz> class buffer { T v[sz]; // ... };
void f() { buffer<char,20> buf1; buffer<complex,20> buf2; buffer<char,20> buf3; buffer<char,100> buf4;
buf1 = buf2; // ошибка: несоответствие типов buf1 = buf3; // нормально buf1 = buf4; // ошибка: несоответствие типов // ... }
Если в шаблоне типа для класса используются параметры, задающие не типы, возможно появление конструкций, выглядящих двусмысленно:
template<int i> class X { /* ... */ };
void f(int a, int b) { X < a > b>; // Как это понимать: X<a> b и потом // недопустимая лексема, или X< (a>b) >; ? }
Этот пример синтаксически ошибочен, поскольку первая угловая скобка > завершает параметр шаблона. В маловероятном случае, когда вам понадобится параметр шаблона, являющийся выражением "больше чем", используйте скобки: X< (a>b)>.
Передача операций как параметров функций
Можно не задавать функцию сравнения как часть типа Vector, а передавать ее как второй параметр функции sort(). Этот параметр является объектом класса, в котором определена реализация операции сравнения:
template<class T> void sort(Vector<T>& v, Comparator<T>& cmp) { unsigned n = v.size();
for (int i = 0; i<n-1; i++) for ( int j = n-1; i<j; j--) if (cmp.lessthan(v[j],v[j-1])) { // меняем местами v[j] и v[j-1] T temp = v[j]; v[j] = v[j-1]; v[j-1] = temp; } }
Этот вариант можно рассматривать как обобщение традиционного приема, когда операция сравнения передается как указатель на функцию.
Воспользоваться этим можно так:
void f(Vector<int>& vi, Vector<String>& vc, Vector<int>& vi2, Vector<char*>& vs) { Comparator<int> ci; Comparator<char*> cs; Comparator<String> cc;
sort(vi,ci); // sort(Vector<int>&); sort(vc,cc); // sort(Vector<String>&); sort(vi2,ci); // sort(Vector<int>&); sort(vs,cs); // sort(Vector<char*>&); }
Отметим, что включение в шаблон класса Comparator как параметра гарантирует, что функция lessthan будет реализовываться подстановкой. В частности, это полезно, если в шаблонной функции используется несколько функций, а не одна операция сравнения, и особенно это полезно, когда эти функции зависят от хранящихся в том же объекте данных.
Производные классы позволяют ввести новые операции
В предыдущем разделе функция сравнения была "встроенной" в теле sort() (просто использовалась операция <). Возможно другое решение, когда ее предоставляет сам шаблонный класс Vector. Однако, такое решение имеет смысл только при условии, что для типов элементов возможно осмысленное понятие сравнения. Обычно в такой ситуации функцию sort() определяют только для векторов, на которых определена операция < :
template<class T> void sort(SortableVector<T>& v) { unsigned n = v.size();
for (int i=0; i<n-1; i++) for (int j=n-1; i<j; j--) if (v.lessthan(v[j],v[j-1])) { // меняем местами v[j] и v[j-1] T temp = v[j]; v[j] = v[j-1]; v[j-1] = temp; } }
Класс SortableVector (сортируемый вектор) можно определить так:
template<class T> class SortableVector : public Vector<T>, public Comparator<T> { public: SortableVector(int s) : Vector<T>(s) { } };
Чтобы это определение имело смысл еще надо определить шаблонный класс Comparator (сравниватель):
template<class T> class Comparator { public: inline static lessthan(T& a, T& b) // функция "меньше" { return strcmp(a,b)<0; } // ... };
Чтобы устранить тот эффект, что в нашем случае операция < дает не тот результат для типа char*, мы определим специальный вариант класса сравнивателя:
class Comparator<char*> { public: inline static lessthan(const char* a, const char* b) // функция "меньше" { return strcmp(a,b)<0; } // ... };
Описание специального варианта шаблонного класса для char* полностью подобно тому, как в предыдущем разделе мы определили специальный вариант шаблонной функции для этой же цели. Чтобы описание специального варианта шаблонного класса сработало, транслятор должен обнаружить его до использования. Иначе будет использоваться создаваемый по шаблону класс. Поскольку класс должен иметь в точности одно определение в программе, использовать и специальный вариант класса, и вариант, создаваемый по шаблону, будет ошибкой.
Поскольку у нас уже специальный вариант класса Comparator для char*, специальный вариант класса SortableVector для char* не нужен, и можем, наконец, попробовать сортировку:
void f(SortableVector<int>& vi, SortableVector<String>& vc, SortableVector<int>& vi2, SortableVector<char*>& vs) { sort(vi); sort(vc); sort(vi2); sort(vs); }
Возможно иметь два вида векторов и не очень хорошо, но, по крайней мере, SortableVector является производным от Vector. Значит если в функции не нужна сортировка, то в ней и не надо знать о классе SortableVector, а там, где нужно, сработает неявное преобразование ссылки на производный класс в ссылку на общий базовый класс. Мы ввели производный от Vector и Comparator класс SortableVector (вместо того, чтобы добавить функции к классу, производному от одного Vector) просто потому, что класс Comparator уже напрашивался в предыдущим примере. Такой подход типичен при создании больших библиотек. Класс Comparator естественный кандидат для библиотеки, поскольку в нем можно указать различные требования к операциям сравнения для разных типов.
Простой шаблон типа
Шаблон типа для класса задает способ построения отдельных классов, подобно тому, как описание класса задает способ построения его отдельных объектов. Можно определить стек, содержащий элементы произвольного типа:
template<class T> class stack { T* v; T* p; int sz;
public: stack(int s) { v = p = new T[sz=s]; } ~stack() { delete[] v; }
void push(T a) { *p++ = a; } T pop() { return *--p; }
int size() const { return p-v; } };
Для простоты не учитывался контроль динамических ошибок. Не считая этого, пример полный и вполне правдоподобный.
Префикс template<class T> указывает, что описывается шаблон типа с параметром T, обозначающим тип, и что это обозначение будет использоваться в последующем описании. После того, как идентификатор T указан в префиксе, его можно использовать как любое другое имя типа. Область видимости T продолжается до конца описания, начавшегося префиксом template<class T>. Отметим, что в префиксе T объявляется типом, и оно не обязано быть именем класса. Так, ниже в описании объекта sc тип T оказывается просто char.
Имя шаблонного класса, за которым следует тип, заключенный в угловые скобки <>, является именем класса (определяемым шаблоном типа), и его можно использовать как все имена класса. Например, ниже определяется объект sc класса stack<char>:
stack<char> sc(100); // стек символов
Если не считать особую форму записи имени, класс stack<char> полностью эквивалентен классу определенному так:
class stack_char { char* v; char* p; int sz; public: stack_char(int s) { v = p = new char[sz=s]; } ~stack_char() { delete[] v; }
void push(char a) { *p++ = a; } char pop() { return *--p; }
int size() const { return p-v; } };
Можно подумать, что шаблон типа - это хитрое макроопределение, подчиняющееся правилам именования, типов и областей видимости, принятым в С++. Это, конечно, упрощение, но это такое упрощение, которое помогает избежать больших недоразумений. В частности, применение шаблона типа не предполагает каких-либо средств динамической поддержки помимо тех, которые используются для обычных "ручных" классов. Не следует так же думать, что оно приводит к сокращению программы.
Обычно имеет смысл вначале отладить конкретный класс, такой, например, как stack_char, прежде, чем строить на его основе шаблон типа stack<T>. С другой стороны, для понимания шаблона типа полезно представить себе его действие на конкретном типе, например int или shape*, прежде, чем пытаться представить его во всей общности.
Имея определение шаблонного класса stack, можно следующим образом определять и использовать различные стеки:
stack<shape*> ssp(200); // стек указателей на фигуры stack<Point> sp(400); // стек структур Point
void f(stack<complex>& sc) // параметр типа `ссылка на // complex' { sc.push(complex(1,2)); complex z = 2.5*sc.pop();
stack<int>*p = 0; // указатель на стек целых p = new stack<int>(800); // стек целых размещается // в свободной памяти for ( int i = 0; i<400; i++) { p->push(i); sp.push(Point(i,i+400)); }
// ... }
Поскольку все функции- члены класса stack являются подстановками, и в этом примере транслятор создает вызовы функций только для размещения в свободной памяти и освобождения.
Функции в шаблоне типа могут и не быть подстановками, шаблонный класс stack с полным правом можно определить и так:
template<class T> class stack { T* v; T* p; int sz; public: stack(int); ~stack();
void push(T); T pop();
int size() const; };
В этом случае определение функции-члена stack должно быть дано где-то в другом месте, как это и было для функций- членов обычных, нешаблонных классов. Подобные функции так же параметризируются типом, служащим параметром для их шаблонного класса, поэтому определяются они с помощью шаблона типа для функции. Если это происходит вне шаблонного класса, это надо делать явно:
template<class T> void stack<T>::push(T a) { *p++ = a; }
template<class T> stack<T>::stack(int s) { v = p = new T[sz=s]; }
Отметим, что в пределах области видимости имени stack<T> уточнение <T> является избыточным, и stack<T>::stack - имя конструктора.
Задача системы программирования, а вовсе не программиста, предоставлять версии шаблонных функций для каждого фактического параметра шаблона типа. Поэтому для приводившегося выше примера система программирования должна создать определения конструкторов для классов stack<shape*>, stack<Point> и stack<int>, деструкторов для stack<shape*> и stack<Point>, версии функций push() для stack<complex>, stack<int> и stack<Point> и версию функции pop() для stack<complex>. Такие создаваемые функции будут совершенно обычными функциями-членами, например:
void stack<complex>::push(complex a) { *p++ = a; }
Здесь отличие от обычной функции-члена только в форме имени класса. Точно так же, как в программе может быть только одно определение функции-члена класса, возможно только одно определение шаблона типа для функции-члена шаблонного класса. Если требуется определение функции-члена шаблонного класса для конкретного типа, то задача системы программирования найти шаблон типа для этой функции-члена и создать нужную версию функции. В общем случае система программирования может рассчитывать на указания от программиста, которые помогут найти нужный шаблон типа.
Важно составлять определение шаблона типа таким образом, чтобы его зависимость от глобальных данных была минимальной. Дело в том, шаблон типа будет использоваться для порождения функций и классов на основе заранее неизвестного типа и в неизвестных контекстах. Практически любая, даже слабая зависимость от контекста может проявиться как проблема при отладке программы пользователем, который, вероятнее всего, не был создателем шаблона типа. К совету избегать, насколько это возможно, использований глобальных имен, следует относиться особенно серьезно при разработке шаблона типа.
Простой шаблон типа для глобальной функции
Начнем с простейшего шаблона для sort():
template<class T> void sort(Vector<T>&);
void f(Vector<int>& vi, Vector<String>& vc, Vector<int>& vi2, Vector<char*>& vs) { sort(vi); // sort(Vector<int>& v); sort(vc); // sort(Vector<String>& v); sort(vi2); // sort(Vector<int>& v); sort(vs); // sort(Vector<char*>& v); }
Какая именно функция sort() будет вызываться определяется фактическим параметром. Программист дает определение шаблона типа для функции, а задача системы программирования обеспечить создание правильных вариантов функции по шаблону и вызов соответствующего варианта. Например, простой шаблон с алгоритмом пузырьковой сортировки можно определить так:
template<class T> void sort(Vector<T>& v) /* Сортировка элементов в порядке возрастания Используется сортировка по методу пузырька */ { unsigned n = v.size();
for (int i=0; i<n-1; i++) for (int j=n-1; i<j; j--) if (v[j] < v[j-1]) { // меняем местами v[j] и v[j-1] T temp = v[j]; v[j] = v[j-1]; v[j-1] = temp; } }
Советуем сравнить это определение с функцией сортировки с тем же алгоритмом из §4.6.9. Существенное отличие этого варианта в том, что вся необходимая информация передается в единственном параметре v. Поскольку тип сортируемых элементов известен (из типа фактического параметра, можно непосредственно сравнивать элементы, а не передавать указатель на производящую сравнение функцию. Кроме того, нет нужды возиться с операцией sizeof. Такое решение кажется более красивым и к тому же оно более эффективно, чем обычное. Все же оно сталкивается с трудностью. Для некоторых типов операция < не определена, а для других, например char*, ее определение противоречит тому, что требуется в приведенном определении шаблонной функции. (Действительно, нам нужно сравнивать не указатели на строки, а сами строки). В первом случае попытка создать вариант sort() для таких типов закончится неудачей (на что и следует надеяться) , а во втором появиться функция, производящая неожиданный результат.
Чтобы правильно сортировать вектор из элементов char* мы можем просто задать самостоятельно подходящее определение функции sort(Vector<char*>&):
void sort(Vector<char*>& v) { unsigned n = v.size();
for (int i=0; i<n-1; i++) for ( int j=n-1; i<j; j--) if (strcmp(v[j],v[j-1])<0) { // меняем местами v[j] и v[j-1] char* temp = v[j]; v[j] = v[j-1]; v[j-1] = temp; } }
Поскольку для векторов из указателей на строки пользователь дал свое особое определение функции sort(), оно и будет использоваться, а создавать для нее определение по шаблону с параметром типа Vector<char*>& не нужно. Возможность дать для особо важных или "необычных" типов свое определение шаблонной функции дает ценное качество гибкости в программировании и может быть важным средством доведения программы до оптимальных характеристик.
Разрешение перегрузки для шаблонной функции
К параметрам шаблонной функции нельзя применять никаких преобразований типа. Вместо этого при необходимости создаются новые варианты функции:
template<class T> T sqrt(t);
void f(int i, double d, complex z) { complex z1 = sqrt(i); // sqrt(int) complex z2 = sqrt(d); // sqrt(double) complex z3 = sqrt(z); // sqrt(complex) // ... }
Здесь для всех трех типов параметров будет создаваться по шаблону своя функция sqrt. Если пользователь захочет чего-нибудь иного, например вызвать sqrt(double), задавая параметр int, нужно использовать явное преобразование типа:
template<class T> T sqrt(T);
void f(int i, double d, complex z) { complex z1 = sqrt(double(i)); // sqrt(double) complex z2 = sqrt(d); // sqrt(double) complex z3 = sqrt(z); // sqrt(complex) // ... }
В этом примере по шаблону будут создаваться определения только для sqrt(double) и sqrt(complex).
Шаблонная функция может перегружаться как простой, так и шаблонной функцией того же имени. Разрешение перегрузки как шаблонных, так и обычных функций с одинаковыми именами происходит за три шага:
Эти правила слишком строгие, и, по всей видимости будут ослаблены, чтобы разрешить преобразования ссылок и указателей, а, возможно, и другие стандартные преобразования. Как обычно, при таких преобразованиях будет действовать контроль однозначности.
Найти функцию с точным сопоставлением параметров (§R.13.2); если такая есть, вызвать ее.Найти шаблон типа, по которому можно создать вызываемую функцию с точным сопоставлением параметров; если такая есть, вызвать ее.Попробовать правила разрешения для обычных функций (§R13.2); если функция найдена по этим правилам, вызвать ее, иначе вызов является ошибкой.
В любом случае, если на первом шаге найдено более одной функции, вызов считается неоднозначным и является ошибкой. Например:
template<class T> T max(T a, T b) { return a>b?a:b; };
void f(int a, int b, char c, char d) { int m1 = max(a,b); // max(int,int) char m2 = max(c,d); // max(char,char) int m3 = max(a,c); // ошибка: невозможно // создать max(int,char) }
Поскольку до генерации функции по шаблону не применяется никаких преобразований типа (правило [2]), последний вызов в этом примере нельзя разрешить как max(a,int(c)). Это может сделать сам пользователь, явно описав функцию max(int,int). Тогда вступает в силу правило [3]:
template<class T> T max(T a, T b) { return a>b?a:b; }
int max(int,int);
void f(int a, int b, char c, char d) { int m1 = max(a,b); // max(int,int) char m2 = max(c,d); // max(char,char) int m3 = max(a,c); // max(int,int) }
Программисту не нужно давать определение функции max(int,int), оно по умолчанию будет создано по шаблону.
Можно определить шаблон max так, чтобы сработал первоначальный вариант нашего примера:
template<class T1, class T2> T1 max(T1 a, T2 b) { return a>b?a:b; };
void f(int a, int b, char c, char d) { int m1 = max(a,b); // int max(int,int) char m2 = max(c,d); // char max(char,char) int m3 = max(a,c); // max(int,char) }
Однако, в С и С++ правила для встроенных типов и операций над ними таковы, что использовать подобный шаблон с двумя параметрами может быть совсем непросто. Так, может оказаться неверно задавать тип результата функции как первый параметр (T1), или, по крайней мере, это может привести к неожиданному результату, например для вызова
max(c,i); // char max(char,int)
Если в шаблоне для функции, которая может иметь множество параметров с различными арифметическими типами, используются два параметра, то в результате по шаблону будет порождаться слишком большое число определений разных функций. Более разумно добиваться преобразования типа, явно описав функцию с нужными типами.
Реализация списка
Реализация функций slist_base очевидна. Единственная трудность связана с обработкой ошибок. Например, что делать если пользователь с помощью функции get() пытается взять элемент из пустого списка. Подобные ситуации разбираются в функции обработки ошибок slist_handler(). Более развитый метод, рассчитанный на особые ситуации, будет обсуждаться в лекции 9.
Приведем полное описание класса slist_base:
class slist_base { slink* last; // last->next является началом списка public: void insert(slink* a); // добавить в начало списка void append(slink* a); // добавить в конец списка slink* get(); // удалить и возвратить // начало списка void clear() { last = 0; }
slist_base() { last = 0; } slist_base(slink* a) { last = a->next = a; }
friend class slist_base_iter; };
Чтобы упростить реализацию обеих функций insert и append, хранится указатель на последний элемент замкнутого списка:
void slist_base_insert(slink* a) // добавить в начало списка { if (last) a->next = last->next; else last = a; last->next = a; }
Заметьте, что last->next - первый элемент списка.
void slist_base::append(slink* a) // добавить в конец списка { if (last) { a->next = last->next; last = last->next = a; } else last = a->next = a; }
slist* slist_base::get() // удалить и возвратить начало списка { if (last == 0) slist_handler("нельзя взять из пустого списка"); slink* f = last->next; if (f== last) last = 0; else last->next = f->next; return f; }
Возможно более гибкое решение, когда slist_handler - указатель на функцию, а не сама функция. Тогда вызов
slist_handler("нельзя взять из пустого списка");
будет задаваться так
(*slist_handler)(" нельзя взять из пустого списка");
Как мы уже делали для функции new_handler (§3.2.6), полезно завести функцию, которая поможет пользователю создавать свои обработчики ошибок:
typedef void (*PFV)(const char*);
PFV set_slist_handler(PFV a) { PFV old = slist_handler; slist_handler = a; return old; }
PFV slist_handler = &default_slist_handler;
Особые ситуации, которые обсуждаются в лекции 9, не только дают альтернативный способ обработки ошибок, но и способ реализации slist_handler.
Шаблоны типа для функций
Использование шаблонных классов означает наличие шаблонных функций-членов. Помимо этого, можно определить глобальные шаблонные функции, т.е. шаблоны типа для функций, не являющихся членами класса. Шаблон типа для функций порождает семейство функций точно также, как шаблон типа для класса порождает семейство классов. Эту возможность мы обсудим на последовательности примеров, в которых приводятся варианты функции сортировки sort(). Каждый из вариантов в последующих разделах будет иллюстрировать общий метод.
Как обычно мы сосредоточимся на организации программы, а не на разработке ее алгоритма, поэтому использоваться будет тривиальный алгоритм. Все варианты шаблона типа для sort() нужны для того, чтобы показать возможности языка м полезные приемы программирования. Варианты не упорядочены в соответствии с тем, насколько они хороши. Кроме того, можно обсудить и традиционные варианты без шаблонов типа, в частности, передачу указателя на функцию, производящую сравнение.
Шаблоны типа для списка
На практике при разработке класса, служащего коллекцией объектов, часто приходится учитывать взаимоотношения использующихся в реализации классов, управление памятью и необходимость определить итератор по содержимому коллекции. Часто бывает так, что несколько родственных классов разрабатываются совместно (§12.2). В качестве примера мы предложим семейство классов, представляющих односвязные списки и шаблоны типа для них.
Шаблоны типа и производные классы
Мы уже видели, что сочетание производных классов (наследование) и шаблонов типа может быть мощным средством. Шаблон типа выражает общность между всеми типами, которые используются как его параметры, а базовый класс выражает общность между всеми представлениями (объектами) и называется интерфейсом. Здесь возможны некоторые простые недоразумения, которых надо избегать.
Два созданных по одному шаблону типа будут различны и между ними невозможно отношение наследования кроме единственного случая, когда у этих типов идентичны параметры шаблона. Например:
template<class T> class Vector { /* ... */ }
Vector<int> v1; Vector<short> v2; Vector<int> v3;
Здесь v1 и v3 одного типа, а v2 имеет совершенно другой тип. Из того факта, что short неявно преобразуется в int, не следует, что есть неявное преобразование Vector<short> в Vector<int>:
v2 = v3; // несоответствие типов
Но этого и следовало ожидать, поскольку нет встроенного преобразования int[] в short[].
Аналогичный пример:
class circle: public shape { /* ... */ };
Vector<circle*> v4; Vector<shape*> v5; Vector<circle*> v6;
Здесь v4 и v6 одного типа, а v5 имеет совершенно другой тип. Из того факта, что существует неявное преобразование circle в shape и circle* в shape*, не следует, что есть неявные преобразования Vector<circle*> в Vector<shape*> или Vector<circle*>* в Vector<shape*>* :
v5 = v6; // несоответствие типов
Дело в том, что в общем случае структура (представление) класса, созданного по шаблону типа, такова, что для нее не предполагаются отношения наследования. Так, созданный по шаблону класс может содержать объект типа, заданного в шаблоне как параметр, а не просто указатель на него. Кроме того, допущение подобных преобразований приводит к нарушению контроля типов:
void f(Vector<circle>* pc) { Vector<shape>* ps = pc; // ошибка: несоответствие типов (*ps)[2] = new square; // круглую ножку суем в квадратное // отверстие (память выделена для // square, а используется для circle }
На примерах шаблонов Islist, Tlink, Slist, Splist, Islist_iter, Slist_iter и SortableVector мы видели, что шаблоны типа дают удобное средство для создания целых семейств классов. Без шаблонов создание таких семейств только с помощью производных классов может быть утомительным занятием, а значит, ведущим к ошибкам. С другой стороны, если отказаться от производных классов и использовать только шаблоны, то появляется множество копий функций-членов шаблонных классов, множество копий описательной части шаблонных классов и во множестве повторяются функции, использующие шаблоны типа.
Список без принудительной связи
После "экскурса" в вопросы построения и использования списка с принудительной связью перейдем к построению списков без принудительной связи. Это значит, что элементы списка не обязаны содержать дополнительную информацию, помогающую в реализации списочного класса. Поскольку мы больше не можем рассчитывать, что объект в списке имеет поле связи, такую связь надо предусмотреть в реализации:
template<class T> struct Tlink : public slink { T info; Tlink(const T& a) : info(a) { } };
Класс Tlink<T> хранит копию объектов типа T помимо поля связи, которое идет от его базового класса slink. Отметим, что используется инициализатор в виде info(a), а не присваивание info=a. Это существенно для эффективности операции в случае типов, имеющих нетривиальные конструкторы копирования и операции присваивания (§7.11). Для таких типов (например, для String) определив конструктор как
Tlink(const T& a) { info = a; }
мы получим, что будет строиться стандартный объект String, а уже затем ему будет присваиваться значение.
Имея класс, определяющий связь, и класс Islist, получить определение списка без принудительной связи совсем просто:
template<class T> class Slist : private slist_base { public: void insert(const T& a) { slist_base::insert(new Tlink<T>(a)); } void append(const T& a) { slist_base::append(new Tlink<T>(a)); } T get(); // ... };
template<class T> T Slist<T>::get() { Tlink<T>* lnk = (Tlink<T>*) slist_base::get(); T i = lnk->info; delete lnk; return i; }
Работать со списком Slist так же просто, как и со списком Ilist. Различие в том, что можно включать в Slist объект, класс которого не является производным от slink, а также можно включать один объект в два списка:
void f(int i) { Slist<int> lst1; Slist<int> lst2;
lst1.insert(i); lst2.insert(i); // ...
int i1 = lst1.get(); int i2 = lst2.get(); // ... }
Однако, список с принудительной связью, например Islist, позволял создавать существенно более эффективную программу и давал более компактное представление. Действительно, при каждом включении объекта в список Slist нужно разместить объект Tlink, а при каждом удалении объекта из Slist нужно удалить объект Tlink, причем каждый раз копируется объект типа T. Когда возникает такая проблема дополнительных расходов, могут помочь два приема. Во-первых, Tlink является прямым кандидатом для размещения с помощью практически оптимальной функции размещения специального назначения (см. §5.5.6). Тогда дополнительные расходы при выполнении программы сократятся до обычно приемлемого уровня. Во-вторых, полезным оказывается такой прием, когда объекты хранятся в "первичном" списке, имеющим принудительную связь, а списки без принудительной связи используются только, когда требуется включение объекта в несколько списков:
void f(name* p) { Islist<name> lst1; Slist<name*> lst2;
lst1.insert(p); // связь через объект `*p' lst2.insert(p); // для хранения `p' используется // отдельный объект типа список // ... }
Конечно, подобные трюки можно делать только в отдельном компоненте программы, чтобы не допустить путаницы списочных типов в интерфейсах различных компонент. Но это именно тот случай, когда ради эффективности и компактности программы на них стоит идти.
Поскольку конструктор Slist копирует параметр для insert(), список Slist пригоден только для таких небольших объектов, как целые, комплексные числа или указатели. Если для объектов копирование слишком накладно или неприемлемо по смысловым причинам, обычно выход бывает в том, чтобы вместо объектов помещать в список указатели на них. Это сделано в приведенной выше функции f() для lst2.
Отметим, что раз параметр для Slist::insert() копируется, передача объекта производного класса функции insert(), ожидающей объект базового класса, не пройдет гладко, как можно было (по наивности) подумать:
class smiley : public circle { /* ... */ };
void g1(Slist<circle>& olist, const smiley& grin) { olist.insert(grin); // ловушка! }
В список будет включена только часть circle объекта типа smiley. Отметим, что эта неприятность будет обнаружена транслятором в том случае, который можно считать наиболее вероятным. Так, если бы рассматриваемый базовый класс был абстрактным, транслятор запретил бы "урезание" объекта производного класса:
void g2(Slist<shape>& olist, const circle& c) { olist.insert(c); // ошибка: попытка создать объект // абстрактного класса }
Чтобы избежать "урезания" объекта нужно использовать указатели:
void g3(Slist<shape*>& plist, const smiley& grin) { olist.insert(&grin); // прекрасно }
Не нужно использовать параметр-ссылку для шаблонного класса:
void g4(Slist<shape&>& rlist, const smiley& grin) { rlist.insert(grin); // ошибка: будет созданы команды, // содержащие ссылку на ссылку (shape&&) }
При генерации по шаблону типа ссылки, используемые подобным образом, приведут ошибкам в типах. Генерация по шаблону типа для функции
Slist::insert(T&);
приведет к появлению недопустимой функции
Slist::insert(shape&&);
Ссылка не является объектом, поэтому нельзя иметь ссылку на ссылку.
Поскольку список указателей является полезной конструкцией, имеет смысл дать ему специальное имя:
template<class T> class Splist : private Slist<void*> { public: void insert(T* p) { Slist<void*>::insert(p); } void append(T* p) { Slist<void*>::append(p); } T* get() { return (T*) Slist<void*>::get(); } };
class Isplist : private slist_base { public: void insert(T* p) { slist_base::insert(p); } void append(T* p) { slist_base::append(p); } T* get() { return (T*) slist_base::get(); } };
Эти определения к тому же улучшают контроль типов и еще больше сокращают необходимость дублировать функции.
Часто бывает полезно, чтобы тип элемента, указываемый в шаблоне типа, сам был шаблонным классом. Например, разреженную матрицу, содержащую даты, можно определить так:
typedef Slist< Slist<date> > dates;
Обратите внимание на наличие пробелов в этом определении. Если между первой и второй угловой скобкой > нет пробелов, возникнет синтаксическая ошибка, поскольку >> в определении
typedef Slist<Slist<date>> dates;
будет трактоваться как операция сдвига вправо. Как обычно, вводимое в typedef имя служит синонимом обозначаемого им типа, а не является новым типом. Конструкция typedef полезна для именования для длинных имен шаблонных классов также, как она полезна для любых других длинных имен типов.
Отметим, что параметр шаблона типа, который может по разному использоваться в его определении, должен все равно указываться среди списка параметров шаблона один раз. Поэтому шаблон типа, в котором используется объект T и список элементов T, надо определять так:
template<class T> class mytemplate { T ob; Slist<T> slst; // ... };
а вовсе не так:
template<class T, class Slist<t> > class mytemplate { T obj; Slist<T> slst; // ... };
В §8.6 и §R.14. 2 даны правила, что может быть параметром шаблона типа.
Список с принудительной связью
Вначале определим простой список, в котором предполагается, что в каждом заносимом в список объекте есть поле связи. Потом этот список будет использоваться как строительный материал для создания более общих списков, в которых объект не обязан иметь поле связи. Сперва в описаниях классов будет приведена только общая часть, а реализация будет дана в следующем разделе. Это делается за тем, чтобы вопросы проектирования классов не затемнялись деталями их реализации.
Начнем с типа slink, определяющего поле связи в односвязном списке:
struct slink { slink* next; slink() { next = 0; } slink(slink* p) { next = p; } };
Теперь можно определить класс, который может содержать объекты любого, производного от slink, класса:
class slist_base { // ... public: int insert(slink*); // добавить в начало списка int append(slink*); // добавить к концу списка slink* get(); // удалить и возвратить начало списка // ... };
Такой класс можно назвать списком с принудительной связью, поскольку его можно использовать только в том случае, когда все элементы имеют поле slink, которое используется как указатель на slist_base. Само имя slist_base (базовый односвязный список) говорит, что этот класс будет использоваться как базовый для односвязных списочных классов. Как обычно, при разработке семейства родственных классов возникает вопрос, как выбирать имена для различных членов семейства. Поскольку имена классов не могут перегружаться, как это делается для имен функций, для обуздания размножения имен перегрузка нам не поможет.
Класс slist_base можно использовать так:
void f() { slist_base slb; slb.insert(new slink); // ... slink* p = slb.get(); // ... delete p; }
Но поскольку структура slink не может содержать никакой информации помимо связи, этот пример не слишком интересен. Чтобы воспользоваться slist_base, надо определить полезный, производный от slink, класс. Например, в трансляторе используются узлы дерева программы name (имя), которые приходится связывать в список:
class name : public slink { // ... };
void f(const char* s) { slist_base slb; slb.insert(new name(s)); // ... name* p = (name*)slb.get(); // ... delete p; }
Здесь все нормально, но поскольку определение класса slist_base дано через структуру slink, приходится использовать явное приведение типа для преобразования значения типа slink*, возвращаемого функцией slist_base::get(), в name*. Это некрасиво. Для большой программы, в которой много списков и производных от slink классов, это к тому же чревато ошибками. Нам пригодилась бы надежная по типу версия класса slist_base:
template<class T> class Islist : private slist_base { public: void insert(T* a) { slist_base::insert(a); } T* get() { return (T*) slist_base::get(); } // ... };
Приведение в функции Islist::get() совершенно оправдано и надежно, поскольку в классе Islist гарантируется, что каждый объект в списке действительно имеет тип T или тип производного от T класса. Отметим, что slist_base является частным базовым классом Islist. Мы нет хотим, чтобы пользователь случайно натолкнулся на ненадежные детали реализации.
Имя Islist (intrusive singly linked list) обозначает односвязный список с принудительной связью. Этот шаблон типа можно использовать так:
void f(const char* s) { Islist<name> ilst; ilst.insert(new name(s)); // ... name* p = ilst.get(); // ... delete p }
Попытки некорректного использования будет выявлены на стадии трансляции:
class expr : public slink { // ... };
void g(expr* e) { Islist<name> ilst; ilst.insert(e); // ошибка: Islist<name>::insert(), // а нужно name* // ... }
Нужно отметить несколько важных моментов относительно нашего примера. Во-первых, решение надежно в смысле типов (преграда тривиальным ошибкам ставится в очень ограниченной части программы, а именно, в функциях доступа из Islist). Во-вторых, надежность типов достигается без увеличения затрат времени и памяти, поскольку функции доступа из Islist тривиальны и реализуются подстановкой. В-третьих, поскольку вся настоящая работа со списком делается в реализации класса slist_base (пока еще не представленной), никакого дублирования функций не происходит, а исходный текст реализации, т.е. функции slist_base, вообще не должен быть доступен пользователю. Это может быть существенно в коммерческом использовании служебных программ для списков. Кроме того, достигается разделение между интерфейсом и его реализацией, и становится возможной смена реализации без перетрансляции программ пользователя. Наконец, простой список с принудительной связью близок по использованию памяти и времени к оптимальному решению. Иными словами, такой подход близок к оптимальному по времени, памяти, упрятыванию данных и контролю типов и в тоже время он обеспечивает большую гибкость и компактность выражений.
К сожалению, объект может попасть в Islist только, если он является производным от slink. Значит нельзя иметь список Islist из значений типа int, нельзя составить список из значений какого-то ранее определенного типа, не являющегося производным от slink. Кроме того, придется постараться, чтобы включить объект в два списка Islist (§6.5.1).
с двойной связью, которые будут
(*2) Определите семейство списков с двойной связью, которые будут двойниками списков с одной связью, определенных в §8.3.(*3) Определите шаблон типа String, параметром которого является тип символа. Покажите как его можно использовать не только для обычных символов, но и для гипотетического класса lchar, который представляет символы не из английского алфавита или расширенный набор символов. Нужно постараться так определить String, чтобы пользователь не заметил ухудшения характеристик программы по памяти и времени или в удобстве по сравнению с обычным строковым классом.(*1.5) Определите класс Record (запись) с двумя членами-данными: count (количество) и price (цена). Упорядочите вектор из таких записей по каждому из членов. При этом нельзя изменять функцию сортировки и шаблон Vector.(*2) Завершите определения шаблонного класса Map, написав недостающие функции-члены.(*2) Задайте другую реализацию Map из §8.8, используя списочный класс с двойной связью.(*2.5) Задайте другую реализацию Map из §8.8, используя сбалансированное дерево. Такие деревья описаны в §6.2.3 книги Д. Кнут "Искусство программирования для ЭВМ" т.1, "Мир", 1978 [K]. (*2) Сравните качество двух реализаций Map. В первой используется класс Link со своей собственной функцией размещения, а во второй - без нее.(*3) Сравните производительность программы подсчета слов из §8.8 и такой же программы, не использующей класса Map. Операции ввода-вывода должны одинаково использоваться в обеих программах. Сравните несколько таких программ, использующих разные варианты класса Map, в том числе и класс из вашей библиотеки, если он там есть.(*2.5) С помощью класса Map реализуйте топологическую сортировку. Она описана в [K] т.1, стр. 323-332. (см. упражнение 6).(*2) Модифицируйте программу из §8.8 так, чтобы она работала правильно для длинных имен и для имен, содержащих пробелы (например, "thumb back").(*2) Определите шаблон типа для чтения различных видов строк, например, таких (предмет, количество, цена).(*2) Определите класс Sort из §8.4.5, использующий сортировку по методу Шелла. Покажите как можно задать метод сортировки с помощью параметра шаблона. Алгоритм сортировки описан в [K] т.3, §5.2.1 (см. упражнение 6).(*1) Измените определения Map и Mapiter так, чтобы постфиксные операции ++ и -- возвращали объект Mapiter.(*1.5) Используйте шаблоны типа в стиле модульного программирования, как это было показано в §8.4.5 и напишите функцию сортировки, рассчитанную сразу на Vector<T> и T[].
Одним из самых полезных видов
Вот ваша цитата
Бьерн Страуструп
Одним из самых полезных видов классов является контейнерный класс, т.е. такой класс, который хранит объекты каких-то других типов. Списки, массивы, ассоциативные массивы и множества - все это контейнерные классы. С помощью описанных в лекциях 5 и 7 средств можно определить класс, как контейнер объектов единственного, известного типа. Например, в §5.3.2 определяется множество целых. Но контейнерные классы обладают тем интересным свойством, что тип содержащихся в них объектов не имеет особого значения для создателя контейнера, но для пользователя конкретного контейнера этот тип является существенным. Следовательно, тип содержащихся объектов должен параметром контейнерного класса, и создатель такого класса будет определять его с помощью типа-параметра. Для каждого конкретного контейнера (т.е. объекта контейнерного класса) пользователь будет указывать каким должен быть тип содержащихся в нем объектов. Примером такого контейнерного класса был шаблон типа Vector из §1.4.3.
В этой лекции исследуется простой шаблон типа stack (стек) и в результате вводится понятие шаблонного класса. Затем рассматриваются более полные и правдоподобные примеры нескольких родственных шаблонов типа для списка. Вводятся шаблонные функции и формулируются правила, что может быть параметром таких функций. В конце приводится шаблон типа для ассоциативного массива.
Возможны ситуации, когда неявность связи
Возможны ситуации, когда неявность связи между шаблонной функцией sort() и шаблонным классом Comparator создает трудности. Неявную связь легко упустить из виду и в то же время разобраться в ней может быть непросто. Кроме того, поскольку эта связь "встроена" в функцию sort(), невозможно использовать эту функцию для сортировки векторов одного типа, если операция сравнения рассчитана на другой тип (см. упражнение 3 в §8.9). Поместив функцию sort() в класс, мы можем явно задавать связь с классом Comparator:
template<class T, class Comp> class Sort { public: static void sort(Vector<T>&); };
Не хочется повторять тип элемента, и это можно не делать, если использовать typedef в шаблоне Comparator:
template<class T> class Comparator { public: typedef T T; // определение Comparator<T>::T static int lessthan(T& a, T& b) { return a < b; } // ... };
В специальном варианте для указателей на строки это определение выглядит так:
class Comparator<char*> { public: typedef char* T; static int lessthan(T a, T b) { return strcmp(a,b) < 0; } // ... };
После этих изменений можно убрать параметр, задающий тип элемента, из класса Sort:
template<class T, class Comp> class Sort { public: static void sort(Vector<T>&); };
Теперь можно использовать сортировку так:
void f(Vector<int>& vi, Vector<String>& vc, Vector<int>& vi2, Vector<char*>& vs) { Sort< int,Comparator<int> >::sort(vi); Sort< String,Comparator<String> >:sort(vc); Sort< int,Comparator<int> >::sort(vi2); Sort< char*,Comparator<char*> >::sort(vs); }
и определить функцию sort() следующим образом:
template<class T, class Comp> void Sort<T,Comp>::sort(Vector<T>& v) { for (int i=0; i<n-1; i++) for (int j=n-1; i<j; j--) if (Comp::lessthan(v[j],v[j-1])) { T temp = v[j]; v[j] = v[j-1]; v[j-1] = temp; } }
Последний вариант ярко демонстрирует как можно соединять в одну программу отдельные ее части. Этот пример можно еще больше упростить, если использовать класс сравнителя (Comp) в качестве единственного параметра шаблона. В этом случае в определениях класса Sort и функции Sort::sort() тип элемента будет обозначаться как Comp::T.
Задание реализации с помощью параметров шаблона
В контейнерных классах часто приходится выделять память. Иногда бывает необходимо (или просто удобно) дать пользователю возможность выбирать из нескольких вариантов выделения памяти, а также позволить ему задавать свой вариант. Это можно сделать несколькими способами. Один из способов состоит в том, что определяется шаблон типа для создания нового класса, в интерфейс которого входит описание соответствующего контейнера и класса, производящего выделение памяти по способу, описанному в §6.7.2:
template<class T, class A> class Controlled_container : public Container<T>, private A { // ... void some_function() { // ... T* p = new(A::operator new(sizeof(T))) T; // ... } // ... };
Шаблон типа здесь необходим, поскольку мы создаем контейнерный класс. Наследование от Container<T> нужно, чтобы класс Controlled_container можно было использовать как контейнерный класс. Шаблон типа с параметром A позволит нам использовать различные функции размещения:
class Shared : public Arena { /* ... */ }; class Fast_allocator { /* ... */ };
Controlled_container<Process_descriptor,Shared> ptbl;
Controlled_container<Node,Fast_allocator> tree;
Controlled_container<Personell_record,Persistent> payroll;
Это универсальный способ предоставлять производным классам содержательную информацию о реализации. Его положительными качествами являются систематичность и возможность использовать функции-подстановки. Для этого способа характерны необычно длинные имена. Впрочем, как обычно, typedef позволяет задать синонимы для слишком длинных имен типов:
typedef Controlled_container<Personell_record,Persistent> pp_record;
pp_record payroll;
Обычно шаблон типа для создания такого класса как pp_record используют только в том случае, когда добавляемая информация по реализации достаточно существенна, чтобы не вносить ее в производный класс ручным программированием. Примером такого шаблона может быть общий (возможно, для некоторых библиотек стандартный) шаблонный класс Comparator (§8.4.2), а также нетривиальные (возможно, стандартные для некоторых библиотек) классы Allocator (классы для выделения памяти). Отметим, что построение производных классов в таких примерах идет по "основному проспекту", который определяет интерфейс с пользователем (в нашем примере это Container). Но есть и "боковые улицы", задающие детали реализации.