Добавил:
Опубликованный материал нарушает ваши авторские права? Сообщите нам.
Вуз: Предмет: Файл:

Программирование на C / C++ / Ален И. Голуб. Правила программирования на Си и Си++ [pdf]

.pdf
Скачиваний:
138
Добавлен:
02.05.2014
Размер:
5.67 Mб
Скачать

С++ для начинающих

822

}

Следующая инструкция в функции-члене min() сравнивает два элемента очереди Queue:

pq->item < min_val

Здесь неявно присутствует требование к типам, которыми может конкретизироваться шаблон класса Queue: такой тип должен либо иметь возможность пользоваться предопределенным оператором меньшедля встроенных типов, либо быть классом, в котором определен оператор operator<(). Если же этого оператора нет, то попытка применить min() к очереди приведет к ошибке компиляции в том месте, где вызывается несуществующий оператор сравнения. (Аналогичная проблема существует и в max(), только касается оператора operator>()).

class LongSouble { public:

LongDouble( double dbval ) : value( dval ) { } bool compareLess( const LongDouble & );

private:

double value;

Предположим, что шаблон класса Queue нужно конкретизировать таким типом:

};

Но в этом классе нет оператора operator<(), позволяющего сравнивать два значения типа LongDouble, поэтому использовать для очереди типа Queue<LongDouble> функции- члены min() и max() нельзя. Одним из решений этой проблемы может стать определение глобальных operator<() и operator>(), в которых для сравнения значений типа Queue<LongDouble> используется функция-член compareLess. Эти глобальные

операторы вызывались бы из min() и max() автоматически при сравнении объектов из очереди.

Однако мы рассмотрим другое решение, связанное со специализацией шаблонов класса: вместо общих определений функций-членов min() и max() при конкретизации шаблона

Queue типом LongDouble мы определим специальные экземпляры

Queue<LongDouble>::min() и Queue<LongDouble>::max(), основанные на функции- члене compareLess() класса LongDouble.

Это можно сделать, если воспользоваться явным определением специализации, где после ключевого слова template идет пара угловых скобок <>, а за ней определение специализации члена класса. В приведенном примере для функций-членов min() и max() класса Queue<LongDouble>, конкретизированного из шаблона, определены явные специализации:

С++ для начинающих

823

// определения явных специализаций

template<> LongDouble Queue<LongDouble>::min()

{

assert( ! is_empty() ); LongDouble min_val = front->item;

for ( QueueItem *pq = front->next; pq != 0; pq = pq->next ) if ( pq->item.compareLess( min_val ) )

min_val = pq->item; return min_val;

}

template<> LongDouble Queue<LongDouble>::max()

{

assert( ! is_empty() ); LongDouble max_val = front->item;

for ( QueueItem *pq = front->next; pq != 0; pq = pq->next ) if ( max_val.compareLess( pq->item ) )

max_val = pq->item; return max_val;

}

Хотя тип класса Queue<LongDouble> конкретизируется по шаблону, в каждом объекте этого типа используются специализированные функции-члены min() и max() не те, что конкретизируются по обобщенным определениям этих функций в шаблоне класса Queue.

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

// объявления явных специализаций функций-членов template <> LongDouble Queue<LongDouble>::min();

объявить, не определяя. Например:

template <> LongDouble Queue<LongDouble>::max();

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

Иногда определение всего шаблона оказывается непригодным для конкретизации некоторым типом. В таком случае программист может специализировать шаблон класса целиком. Напишем полное определение класса Queue<LongDouble>:

С++ для начинающих

824

// QueueLD.h: определяет специализацию класса Queue<LongDouble> #include "Queue.h"

template<> Queue<LongDouble> { Queue<LongDouble>(); ~Queue<LongDouble>();

LongDouble& remove();

void add( const LongDouble & ); bool is_empty() const; LongDouble min();

LongDouble max(); private:

// Некоторая реализация

};

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

приведенном примере не включить заголовочный файл Queue.h перед определением явной специализации шаблона, компилятор выдаст сообщение об ошибке, указывая, что Queue это не имя шаблона.

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

общего шаблона никогда не используются для создания определений членов явной специализации: множества членов этих шаблонов могут различаться. Чтобы предоставить определение явной специализации для типа класса Queue<LongDouble>, придется определить не только функции-члены min() и max(), но и все остальные.

Если класс специализируется целиком, лексемы template<> помещаются только перед

#include "QueueLD.h"

//определяет функцию-член min()

//из специализированного шаблона класса

определением явной специализации всего шаблона:

LongDouble Queue<LongDouble>::min() { }

Класс не может в одних файлах конкретизироваться из общего определения шаблона, а в других из специализированного, если задано одно и то же множество аргументов. Например, специализацию шаблона QueueItem<LongDouble> необходимо объявлять в

// ---- File1.C ----

#include "Queue.h"

void ReadIn( Queue<LongDouble> *pq ) {

//использование pq->add()

//приводит к конкретизации QueueItem<LongDouble>

}

каждом файле, где она используется:

С++ для начинающих

825

 

 

// ---- File2.C ----

 

 

 

 

 

 

#include "QueueLD.h"

 

 

 

void ReadIn( Queue<LongDouble> * );

 

 

 

int main() {

 

 

 

// используется определение специализации для Queue<LongDouble>

 

 

 

Queue<LongDouble> *qld = new Queue<LongDouble>;

 

 

 

ReadIn( qld );

 

 

 

// ...

 

 

 

}

 

 

 

 

 

 

 

Эта программа некорректна, хотя большинство компиляторов ошибку не обнаружат:

 

заголовочный файл QueueLD.h следует включать во все файлы, где используется

 

Queue<LongDouble>, причем до первого использования.

 

16.10. Частичные специализации шаблонов классов A

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

Рассмотрим шаблон класса Screen, введенный в разделе 16.2. Частичная специализации

template <int hi, int wid> class Screen {

// ...

};

// частичная специализация шаблона класса Screen template <int hi>

class Screen<hi, 80> { public:

Screen();

 

// ...

 

private:

_screen;

string

string::size_type _cursor;

short

_height;

// для экранов с 80 колонками используются специальные алгоритмы

Screen<hi,80> дает более эффективную реализацию для экранов с 80 столбцами:

};

Частичная специализация шаблона класса это шаблон, и ее определение похоже на определение шаблона. Оно начинается с ключевого слова template, за которым следует список параметров, заключенный в угловые скобки. Список параметров здесь отличается от соответствующего списка параметров общего шаблона. Для частичной специализации шаблона Screen есть только один параметр-константа hi, поскольку значение второго

С++ для начинающих

826

аргумента равно 80, т.е. в данном списке представлены только те параметры, для которых фактические аргументы еще неизвестны.

Имя частичной специализации совпадает с именем того общего шаблона, которому она соответствует, в нашем случае Screen. Однако за ее именем всегда следует список аргументов. В примере выше этот список выглядит как <hi,80>. Поскольку значение аргумента для первого параметра шаблона неизвестно, то на этом месте в списке стоит имя параметра шаблона; вторым же аргументом является значение 80, которым частично специализирован шаблон.

Частичная специализация шаблона класса неявно конкретизируется при использовании в программе. В следующем примере частичная специализация конкретизируется аргументом шаблона 24 вместо hi:

Screen<24,80> hp2621;

Обратите внимание, что экземпляр Screen<24,80> может быть конкретизирован не только из частично специализированного, но и из общего шаблона. Почему же тогда компилятор остановился именно на частичной специализации? Если для шаблона класса объявлены частичные специализации, компилятор выбирает то определение, которое является наиболее специализированным для заданных аргументов. Если же ни одно из них не подходит, используется общее определение шаблона. Например, при

конкретизации экземпляра Screen<40,132> соответствующей аргументам шаблона специализации нет. Наш вариант применяется только для конкретизации типа Screen с 80 колонками.

Определение частичной специализации не связано с определением общего шаблона. У него может быть совершенно другой набор членов, а также собственные определения функций-членов, статических членов и вложенных типов. Содержащиеся в общем

шаблоне определения членов никогда не употребляются для конкретизации членов его частичной специализации. Например, для частичной специализации Screen<hi,80>

// конструктор для частичной специализации Screen<hi,80> template <int hi>

Screen<hi,80>::Screen() : _height( hi ), _cursor( 0 ), _screen( hi * 80, bk )

должен быть определен свой конструктор:

{ }

Если для конкретизации некоторого класса применяется частичная специализация, то определение конструктора из общего шаблона не используется даже тогда, когда определение конструктора Screen<hi,80> отсутствует.

16.11. Разрешение имен в шаблонах классов A

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

С++ для начинающих

827

// Queue.h: #include <iostream> #include <cstdlib>

// определение класса Queue

template <class Type>

Type Queue<Type>::remove() { if ( is_empty() ) {

cerr << "remove() вызвана для пустой очереди\n"; exit(-1);

}

QueueItem<Type> *pt = front; front = front->next;

Type retval = pt->item; delete pt;

cout << "удалено значение: "; cout << retval << endl;

return retval;

}

В выражении

cout << retval << endl;

переменная retval имеет тип Type, и ее фактический тип неизвестен до конкретизации функции-члена remove(). То, какой оператор operator<<() будет выбран, зависит от фактического типа retval, подставленного вместо Type. При разных конкретизациях remove() могут вызываться разные operator<<(). Поэтому мы говорим, что выбранный оператор вывода зависит от параметра шаблона.

Однако для вызова функции exit() ситуация иная. Ее фактическим аргументом является литерал, значение которого одинаково при всех конкретизациях remove(). Поскольку при обращении к функции не используются аргументы, типы которых зависят от параметра шаблона Type, гарантируется, что всегда будет вызываться exit(), объявленная в заголовочном файле cstdlib. По той же причине в выражении

cout << "удалено значение: ";

всегда вызывается глобальный оператор

ostream& operator<<( ostream &, const char * );

Аргумент "удалено значение: " это C-строка символов, и ее тип не зависит от параметра шаблона Type. Поэтому в любом конкретизированном экземпляре remove()употребление operator<<() имеет одинаковый смысл. Один и тот же смысл во всех конкретизациях шаблона имеют те конструкции, которые не зависят от параметров шаблона.

Таким образом, два шага разрешения имени в определениях шаблонов классов или их членов состоят в следующем:

∙ Имена, не зависящие от параметров шаблона, разрешаются во время его определения.

С++ для начинающих

828

Имена, зависящие от параметров шаблона, разрешаются во время его

 

 

конкретизации.

 

Такой подход удовлетворяет требованиям как разработчика класса, так и его пользователя. Например, разработчикам необходимо управлять процессом разрешения имен. Если шаблон класса входит в состав библиотеки, в которой определены также другие шаблоны и функции, то желательно, чтобы при конкретизации шаблона класса и его членов по возможности применялись именно библиотечные компоненты. Это гарантирует первый шаг разрешения имени. Если использованное в определении шаблона имя не зависит от параметров шаблона, то оно разрешается в результате просмотра всех объявлений, видимых в заголовочном файле, включенном перед определением шаблона.

Разработчик класса должен позаботиться о том, чтобы были видимы объявления всех не зависящих от параметров шаблона имен, употребленных в его определении. Если объявление такого имени не найдено, то определение шаблона считается ошибочным. Если бы перед определением функции-члена remove() в шаблоне класса Queue не были включены файлы iostream и cstdlib, то в выражении

cout << "удалено значение: ";

и при компиляции вызова функции exit() были бы обнаружены ошибки.

Второй шаг разрешения имени необходим, если поиск производится среди функций и операторов, зависящих от типа, которым конкретизирован шаблон. Например, если шаблон класса Queue конкретизируется типом класса LongDouble (см. раздел 16.9), то желательно, чтобы внутри функции-члена remove()в следующем выражении

cout << retval << endl;

#include "Queue.h" #include "ldouble.h"

//содержит:

//class LongDouble { ... };

//ostream& operator<<( ostream &, const LongDouble & );

int main() {

//конкретизация Queue<LongDouble> Queue<LongDouble> *qld = new Queue<LongDouble>;

//конкретизация Queue<LongDouble>::remove()

//вызывает оператор вывода для LongDouble

qld->remove();

// ...

вызывался оператор operator<<(), ассоциированный с классом LongDouble:

}

Место в программе, где происходит конкретизация шаблона, называется точкой конкретизации. Она определяет, какие объявления принимаются компилятором во внимание для имен, зависящих от параметров шаблона.

Точка конкретизации шаблона всегда находится в области видимости пространства имен и непосредственно предшествует объявлению или определению, которое ссылается на

С++ для начинающих

829

конкретизированный экземпляр. Точка конкретизации функции-члена или статического члена шаблона класса всегда следует непосредственно за объявлением или определением, которое ссылается на конкретизированный член.

В предыдущем примере точка конкретизации Queue<LongDouble> находится перед main(), и при разрешении зависящих от параметров имен, которые используются в определении шаблона Queue, компилятор просматривает все объявления до этой точки.

Аналогично при таком разрешении в определении remove() компилятор просматривает все объявления до точки конкретизации, расположенной после main().

Как отмечалось в разделе 16.2, шаблон конкретизируется, если он используется в контексте, требующем полного определения класса. Члены шаблона не конкретизируются автоматически вместе с ним, а лишь тогда, когда сами используются в программе.

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

16.12. Пространства имен и шаблоны классов

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

#include <iostream> #include <cstdlib>

namespace cplusplus_primer {

template <class Type> class Queue { // ...

};

template <class Type> Type Queue<Type>::remove()

{

// ...

}

либо воспользоваться using-объявлением:

}

Если имя Queue шаблона класса используется вне пространства имен cplusplus_primer, то оно должно быть квалифицировано этим именем или введено с помощью using-объявления. Во всех остальных отношениях шаблон Queue используется так, как описано выше: конкретизируется, может иметь функции-члены, статические члены, вложенные типы и т.д. Например:

С++ для начинающих

830

int main() {

// using-объявление

using cplusplus_primer Queue;

//ссылается на шаблон класса в пространстве имен cplusplus_primer Queue<int> *p_qi = new Queue<int>;

//...

p_qi->remove();

}

Шаблон cplusplus_primer::Queue<int> конкретизируется, так как использован в выражении new:

... = new Queue<int>;

p_qi это указатель на тип класса cplusplus_primer::Queue<int>. Когда он применяется для адресации функции-члена remove(), то речь идет о члене именно этого конкретизированного экземпляра класса.

Объявление шаблона класса в пространстве имен влияет также на объявления специализаций и частичных специализаций шаблона класса и его членов (см. разделы 16.9 и 16.10). Такая специализация должна быть объявлена в том же пространстве имен, где и общий шаблон.

В следующем примере в пространстве имен cplusplus_primer объявляются специализации типа класса Queue<char *> и функции-члена remove() класса

#include <iostream> #include <cstdlib>

namespace cplusplus_primer {

template <class Type> class Queue { ... };

template <class Type>

Type Queue<Type>::remove() { ... }

// объявление специализации

//для cplusplus_primer::Queue<char *> template<> class Queue<char*> { ... };

//объявление специализации

//для функции-члена cplusplus_primer::Queue<double>::remove()

template<> double Queue<double>::remove() { ... }

Queue<double>:

}

Хотя специализации являются членами cplusplus_primer, их определения в этом пространстве отсутствуют. Определить специализацию шаблона можно и вне пространства имен при условии, что определение будет находиться в некотором пространстве, объемлющем cplusplus_primer, и имя специализации будет квалифицировано его именем :

С++ для начинающих

831

namespace cplusplus_primer

{

// определение Queue и его функций-членов

}

//объявление специализации

//cplusplus_primer::Queue<char*>

template<> class cplusplus_primer::Queue<char*> { ... };

//объявление специализации функции-члена

//cplusplus_primer::Queue<double>::remove()

template<> double cplusplus_primer::Queue<double>::remove()

{ ... }

Объявления специализаций класса cplusplus_primer::Queue<char*> и функции-члена remove() для класса cplusplus_primer::Queue<double> находятся в глобальной области видимости. Поскольку такая область содержит пространство имен cplusplus_primer, а имена специализаций квалифицированы его именем, то определения специализаций для шаблона Queue вполне законны.

16.13. Шаблон класса Array

В этом разделе мы завершим реализацию шаблона класса Array, введенного в разделе 2.5 (этот шаблон будет распространен на одиночное наследование в разделе 18.3 и на множественное наследование в разделе 18.6). Так выглядит полный заголовочный файл: