Бьярн Страуструп - Язык программирования C++

Следовательно операция, изменяющая состояние объекта класса, должна быть членом или глобальной функцией с параметром-ссылкой без спецификации const. Операции над основными типами, которые требуют в качестве операндов адреса (=, *, ++ и т.д.), для пользовательских типов естественно определять как члены.

Обратно, если требуется неявное преобразование типа для всех операндов некоторой операции, то реализующая ее функция должна быть не членом, а глобальной функцией и иметь параметр типа ссылки со спецификацией const или нессылочный параметр. Так обычно обстоит дело с функциями, реализующими операции, которые для основных типов не требуют адресов в качестве операндов (+, -, ||

и т.д.).

Если операции преобразования типа не определены, то нет неопровержимых доводов в пользу функции-члена перед функцией-другом с параметром-ссылкой и наоборот. Бывает, что программисту просто одна форма записи вызова нравится больше, чем другая. Например, многим для обозначения функции обращения матрицы m больше нравится запись inv(m), чем m.inv(). Конечно, если функция inv() обращает саму матрицу m, а не возвращает новую, обратную m, матрицу, то inv() должна быть членом.

При всех прочих равных условиях лучше все-таки остановиться на функции-члене. Можно привести такие доводы. Нельзя гарантировать, что когда-нибудь не будет определена операция обращения. Нельзя во всех случаях гарантировать, что будущие изменения не повлекут за собой изменения в состоянии объекта. Запись вызова функции-члена ясно показывает программисту, что объект может быть изменен, тогда как запись с параметром-ссылкой далеко не столь очевидна. Далее, выражения допустимые в функции-члене могут быть существенно короче эквивалентных выражений в глобальной функции. Глобальная функция должна использовать явно заданные параметры, а в функции-члене можно неявно использовать указатель this. Наконец, поскольку имена членов не являются глобальными именами, они обычно оказываются короче, чем имен глобальных функций.

7.13 Предостережения

Как и всякое другое языковое средство, перегрузка операций может использоваться разумно и неразумно. В частности, возможностью придавать новый смысл обычным операциям можно воспользоваться так, что программа будет совершенно непостижимой. Представьте, каково будет читателю, если в своей программе вы переопределили операцию + так, чтобы она обозначала вычитание. Описанный здесь механизм перегрузки будет защищать программиста и пользователя от таких безрассудств. Поэтому программист не может изменить ни смысл операций над основными типами данных, такими, как int, ни синтаксис выражений и приоритеты операций для них.

По всей видимости перегрузку операций имеет смысл использовать для подражания традиционному использованию операций. Запись с обычным вызовом функции можно использовать в тех случаях, когда традиционной записи с базовой операцией не существует, или, когда набор операций, которые допускают перегрузку, не достаточен, чтобы записать с его помощью нужные действия.

7.14 Упражнения

1. (*2) Определите итератор для класса string. Определите операцию конкатенации + и операцию += , значащую "добавить в конец строки". Какие еще операции вы хотели бы и смогли определить для этого класса?

2.(*1.5) Определите для строкового класса операцию выделения подстроки с помощью перегрузки ().

3.(*3) Определите класс string таким образом, чтобы операцию выделения подстроки можно было применять к левой части присваивания. Вначале напишите вариант, в котором строку можно присваивать подстроке той же длины, а затем вариант с различными длинами строк.

4.(*2) Разработайте класс string таким образом, чтобы объекты его трактовались при передаче параметров и присваивании как значения, т.е. чтобы в классе string копировались сами представления строк, а не только управляющие структуры.

5.(*3) Измените класс string из предыдущего упражнения так, чтобы строки копировались только при необходимости. Это значит, что нужно хранить одно общее представления двух одинаковых строк

201

до тех пор, пока одна из них не изменится. Не пытайтесь задать операцию выделения подстроки, которую одновременно можно применять и к левой части присваивания.

6.(*4) Определите класс string, обладающий перечисленными в предыдущих упражнениях свойствами: объекты его трактуются как значения, копирование является отложенным (т.е. происходит только при необходимости) и операцию выделения подстроки можно применять к левой части присваивания.

7.(*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 и Y как целые типы. Измените программу так, чтобы ее можно было выполнить и она напечатала значения всех правильных выражений.

8.(*2) Определите класс INT, который будет эквивалентен типу int. Подсказка: определите функцию

INT::operator int().

9.(*1) Определите класс RINT, который будет эквивалентен типу int, за исключением того, что допустимыми будут только операции: + (унарный и бинарный), - (унарный и бинарный), *, / и %. Подсказка: не надо определять RINT::operator int().

10. (*3) Определите класс LINT, эквивалентный классу RINT, но в нем для представления целого должно использоваться не менее 64 разрядов.

11. (*4) Определите класс, реализующий арифметику с произвольной точностью. Подсказка: Придется использовать память так, как это делается в классе string.

12. (*2) Напишите программу, в которой благодаря макрокомандам и перегрузке будет невозможно разобраться. Совет: определите для типа INT + как -, и наоборот; с помощью макроопределения задайте int как INT. Кроме того, большую путаницу можно создать, переопределяя широко известные функции, и используя параметры типа ссылки и задавая вводящие в заблуждение комментарии.

13. (*3) Обменяйтесь решениями упражнения [12] с вашим другом. Попробуйте понять, что делает его программа, не запуская ее. Если вы сделаете это упражнение, вам станет ясно, чего надо избегать.

14. (*2) Перепишите примеры с классами complex ($$7.3), tiny ($$7.3.2) и string ($$7.11), не используя дружественные функции. Используйте только функции-члены. Проверьте новые версии этих

202

классов. Сравните их с версиями, в которых используются дружественные функции. Обратитесь к упражнению 5.3.

15. (*2) Определите тип vec4 как вектор из четырех чисел с плавающей точкой. Определите для него функцию operator[]. Для комбинаций векторов и чисел с плавающей точкой определите операции: +, -, *, /, =, +=, -=, *= и /=.

16. (*3) Определите класс mat4 как вектор из четырех элементов типа vec4. Определите для него функцию operator[], возвращающую vec4. Определите для этого типа обычные операции с матрицами. Определите в mat4 функцию, производящую преобразование Гаусса с матрицей.

17. (*2) Определите класс vector, аналогичный классу vec4, но здесь размер вектора должен задаваться как параметр конструктора vector::vector(int).

18. (*3) Определите класс matrix, аналогичный классу mat4, но здесь размерности матрицы должны задаваться как параметры конструктора matrix::matrix(int,int).

19. (*3) Завершите определение класса CheckedPtrToT из $$7.10 и проверьте его. Чтобы определение этого класса было полным, необходимо определить, по крайней мере, такие операции: *, ->, =, ++ и --. Не выдавайте динамическую ошибку, пока действительно не произойдет обращение по указателю с неопределенным значением.

20.(*1.5) Перепишите пример с программой подсчета слов из $$7.7 так, чтобы в ней не было заранее заданной максимальной длины слова.

203

ГЛАВА 8. ШАБЛОНЫ ТИПА

Вот ваша цитата - Бьерн Страуструп

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

8.1 Введение

Одним из самых полезных видов классов является контейнерный класс, т.е. такой класс, который хранит объекты каких-то других типов. Списки, массивы, ассоциативные массивы и множества - все это контейнерные классы. С помощью описанных в главах 5 и 7 средств можно определить класс, как контейнер объектов единственного, известного типа. Например, в $$5.3.2 определяется множество целых. Но контейнерные классы обладают тем интересным свойством, что тип содержащихся в них объектов не имеет особого значения для создателя контейнера, но для пользователя конкретного контейнера этот тип является существенным. Следовательно, тип содержащихся объектов должен параметром контейнерного класса, и создатель такого класса будет определять его с помощью типапараметра. Для каждого конкретного контейнера (т.е. объекта контейнерного класса) пользователь будет указывать каким должен быть тип содержащихся в нем объектов. Примером такого контейнерного класса был шаблон типа Vector из $$1.4.3.

В этой главе исследуется простой шаблон типа stack (стек) и в результате вводится понятие шаблонного класса. Затем рассматриваются более полные и правдоподобные примеры нескольких родственных шаблонов типа для списка. Вводятся шаблонные функции и формулируются правила, что может быть параметром таких функций. В конце приводится шаблон типа для ассоциативного массива.

8.2 Простой шаблон типа

Шаблон типа для класса задает способ построения отдельных классов, подобно тому, как описание класса задает способ построения его отдельных объектов. Можно определить стек, содержащий элементы произвольного типа:

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>.

204

Отметим, что в префиксе 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 являются подстановками, и в этом примере транслятор создает вызовы функций только для размещения в свободной памяти и освобождения.

Функции в шаблоне типа могут и не быть подстановками, шаблонный класс stack с полным правом можно определить и так:

template<class T> class stack { T* v;

T* p;

205

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; }

Здесь отличие от обычной функции-члена только в форме имени класса. Точно так же, как в программе может быть только одно определение функции-члена класса, возможно только одно определение шаблона типа для функции-члена шаблонного класса. Если требуется определение функции-члена шаблонного класса для конкретного типа, то задача системы программирования найти шаблон типа для этой функции-члена и создать нужную версию функции. В общем случае система программирования может рассчитывать на указания от программиста, которые помогут найти нужный шаблон типа.

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

8.3 Шаблоны типа для списка

На практике при разработке класса, служащего коллекцией объектов, часто приходится учитывать взаимоотношения использующихся в реализации классов, управление памятью и необходимость определить итератор по содержимому коллекции. Часто бывает так, что несколько родственных классов разрабатываются совместно ($$12.2). В качестве примера мы предложим семейство классов, представляющих односвязные списки и шаблоны типа для них.

206

Вначале определим простой список, в котором предполагается, что в каждом заносимом в список объекте есть поле связи. Потом этот список будет использоваться как строительный материал для создания более общих списков, в которых объект не обязан иметь поле связи. Сперва в описаниях классов будет приведена только общая часть, а реализация будет дана в следующем разделе. Это делается за тем, чтобы вопросы проектирования классов не затемнялись деталями их реализации.

Начнем с типа slink, определяющего поле связи в односвязном списке:

struct slink { slink* next;

slink() { next = 0; } slink(slink* p) { next = p; }

};

Теперь можно определить класс, который может содержать объекты любого, производного от slink, класса:

Такой класс можно назвать списком с принудительной связью, поскольку его можно использовать только в том случае, когда все элементы имеют поле 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();

207

// ...

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, вообще не должен быть доступен пользователю. Это может быть существенно в коммерческом использовании служебных программ для списков. Кроме того, достигается разделение между интерфейсом и его реализацией, и становится возможной смена реализации без перетрансляции программ пользователя. Наконец, простой список с принудительной связью близок по использованию памяти и времени к оптимальному решению. Иными словами, такой подход близок к оптимальному по времени, памяти, упрятыванию данных и контролю типов и в тоже

208

время он обеспечивает большую гибкость и компактность выражений.

К сожалению, объект может попасть в Islist только, если он является производным от slink. Значит нельзя иметь список Islist из значений типа int, нельзя составить список из значений какого-то ранее определенного типа, не являющегося производным от slink. Кроме того, придется постараться, чтобы включить объект в два списка Islist ($$6.5.1).

8.3.2 Список без принудительной связи

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

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);

209