По умолчанию шаблон представляет единственное определение, которое должно использоваться для всех аргументов шаблона (или комбинаций аргументов шаблона). Однако иногда возникает желание использовать одну реализацию шаблона, когда в качестве аргумента шаблона фигурирует, например, указатель, другую – когда аргумент указателем не является. Это можно реализовать, обеспечив альтернативные определения шаблона и предоставив компилятору возможность осуществлять выбор нужного варианта на основе аргументов шаблона, указанных при его использовании. Такие альтернативные определения шаблона называются специализациями, определяемыми пользовате-лем, или просто пользовательскими специализациями.
Рассмотрим возможные использования шаблона Vector.
template <class T> class Vector //общий тип Vector
{
T *v;
int sz;
public:
Vector();
explicit Vector(int);
T &elem (int) {return v[i];}
T &operator[](int i);
void Swap(Vector&);
…
};
Vector <int> vi;
Vector <Shape*> vps;
Vector <string> vs;
Vector <char*> vpc;
Vector <Node*> vpn;
Большинство векторов будут векторами указателей некоторого типа. В большинстве реализаций C++ код функций шаблона дублируется. Это положительно сказывается на производительности, но приводит к разбуханию кода. Однако у нас есть возможность заставить все эти вектора совместно пользоваться единственной реализацией шаблона. Это можно выразить с помощью специализации.
Определим специализацию Vector для указателей на void:
template <> class Vector<void*>
{
void **p;
…
void *&operator[](int);
};
Эту специализацию можно использовать в качестве общей реализации для всех векторов указателей. Префикс template<> говорит о том, что речь идет о специализации, которая может быть указана без параметра шаблона. Аргументы шаблона, для которых должна использоваться специализация, задаются в угловых скобках <> после имени. То есть <void*> означает, что данное определение должно использоваться как реализация для всех Vector, у которых T является void*.
Vector<void*> является полной специализацией. То есть здесь нет параметра шаблона, который бы следовало задавать или который бы выводился при инстанцировании, когда мы используем специализацию. Vector<void*> используется с векторами, объявленными следующим образом:
Vector<void*> vpv;
Для определения специализации, которая используется для любого вектора указателей и только для векторов указателей, нам требуется частичная специализация:
template <class T> class Vector<T*>:
private Vector<void*>
{
public:
typedef Vector<void*> Base;
Vector():Base();
explicit Vector(int):Base(int){}
T *&elem (int i)
{return reinterpret_cast<T *&>(Base::elem(i));}
T *&operator[](int i)
{
return reinterpret_cast<T *&>(Base::operator[](i));
}
…
};
Образец специализации <T*> после имени означает, что эта специализация должна использоваться для каждого типа указателя, то есть это определение используется для каждого Vector, аргумент шаблона которого можно выразить в виде T*. Например:
//<T*> - это <Shape*>, поэтому T - Shape
Vector <Shape*> vps;
//<T*> - это <int**>, поэтому T – int*
Vector <int**> vppi;
Обратите внимание, что когда используется частичная специализация, параметр шаблона выводится по образцу специализации; параметр шаблона не является фактическим аргументом шаблона. В частности, для Vector<Shape*>, T – это Shape, а не Shape*.
При наличии такой частичной специализации Vector мы имеем совместно используемую реализацию для всех векторов указателей. Класс Vector<T*> является просто интерфейсом к Vector<void*>, выполненным исключительно с использованием механизмов наследования и встраивания.
Общий шаблон должен быть объявлен прежде любой специализации. Например:
template <class T> class List<T*> {…};
template <class T> class List {…}; /* ошибка: общий шаблон после инициализации
*/
Если пользователь специализирует где-нибудь шаблон, эта специализация должна быть в области видимости при каждом использовании шаблона с типом, для которого он был специализирован. Например:
template <class T> class List {…};
List <int*> li;
template <class T> class List<T*> {…}; // ошибка
В этом примере специализация List для int* была сделана после использования List <int*>.
Все специализации шаблона должны быть объявлены в том же самом пространстве имен, что и сам шаблон. Если используется явно объявленная специализация (в отличие от сгенерированной из более общего шаблона), то она должна быть где-то явно определена. Другими словами, явная специализация шаблона означает, что для этой специализации не генерируется определение.
Одна специализация считается более специализированной, чем другая, если каждый список аргументов, соответствующий образцу первой специализации, так же соответствует и второй специализации, но не наоборот. Например:
// общий шаблон
template <class T> class Vector;
// специализация для любого указателя
template <class T> class Vector <T*>;
// специализация для void*
template < > class Vector < >;
Любой тип можно использовать в качестве аргумента шаблона для наиболее
общего класса Vector, но только указатели можно использовать с Vector <T*> и только указатели void* разрешается применять с Vector <void*>Естественно, специализация также полезна для шаблонов функций. Как и в случае с классами, используется префикс template<>, который означает, что речь идет о специализации, оторую можно указывать без параметра шаблона. Например, пусть у нас есть шаблон функции, осуществляющей сравнение:
template <class T> bool Less(T a, T b)
{ return a<b; }
Однако эта функция будет некорректно работать в случае передачи ей в качестве параметров типа char*, так как в этом случае будут сравниваться адреса первых char в каждой строке, хотя изначально предполагалось сравнивать символы. Простая специализация функции Less для const char* поможет решить эту проблему:
template <> bool Less<const char*> (const char *a, const char *b)
{ return strcmp(a, b) < 0; }
Так как аргумент шаблона может быть выведен по списку аргументов функции, нет необходимости его явно указывать, поэтому можно упростить запись:
template <> bool Less (const char *a, const char *b)
{ return strcmp(a, b) < 0; }
Специализация полезна, когда существует более эффективная альтернатива общему алгоритму для конкретных аргументов шаблона. Кроме того, специализация отлично работает, когда нерегулярность типа аргумента приводит к тому, что общий алгоритм выдает неправильный результат. Этими самыми нерегулярными типами часто являются встроенные указатели и массивы. |
Главная
Каталог файлов
