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

       

Шаблоны-члены


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

template <class T>

class Queue {

private:

   // шаблон класса-члена

   template <class Type>

      class CL

   {

      Type member;

      T mem;

   };

   // ...

public:



   // шаблон функции-члена

   template <class Iter>

      void assign( Iter first, Iter last )

   {

      while ( ! is_empty() )

         remove();     // вызывается Queue<T>::remove()

      for ( ; first != last; ++first )

          add( *first );  // вызывается Queue<T>::add( const T & )

   }

}

(Отметим, что шаблоны-члены не поддерживаются компиляторами, написанными до принятия стандарта C++. Эта возможность была добавлена в язык для поддержки реализации абстрактных контейнерных типов, представленных в главе 6.)

Объявление шаблона-члена имеет собственные параметры. Например, у шаблона класса CL есть параметр Type, а у шаблона функции assign() – параметр Iter. Помимо этого, в определении шаблона-члена могут использоваться параметры объемлющего шаблона класса. Например, у шаблона CL есть член типа T, представляющего параметр включающего шаблона Queue.

Объявление шаблона-члена в шаблоне класса Queue означает, что конкретизация Queue потенциально может содержать бесконечное число различных вложенных классов CL функций-членов assign(). Так, конкретизированный экземпляр Queue<int> включает вложенные типы:

Queue<int>::CL<char>

Queue<int>::CL<string>

и вложенные функции:

void Queue<int>::assign( int *, int * )

void Queue<int>::assign( vector<int>::iterator,

                         vector<int>::iterator )

Для шаблона-члена действуют те же правила доступа, что и для других членов класса. Так как шаблон CL является закрытым членом шаблона Queue, то лишь функции-члены и друзья Queue могут ссылаться на его конкретизации. С другой стороны, шаблон функции assign() объявлен открытым членом и, значит, доступен во всей программе.


Шаблон- член конкретизируется при его использовании в программе. Например, assign() конкретизируется в момент обращения к ней из main():

int main()

{

   // конкретизация Queue<int>

   Queue<int> qi;

   // конкретизация Queue<int>::assign( int *, int * )

   int ai[4] = { 0, 3, 6, 9 };

   qi.assign( ai, ai + 4 );

   // конкретизация Queue<int>::assign( vector<int>::iterator,

   //                                     vector<int>::iterator )

   vector<int> vi( ai, ai + 4 );

   qi.assign( vi.begin(), vi.end() );

}

Шаблон функции assign(), являющийся членом шаблона класса Queue, иллюстрирует необходимость применения шаблонов-членов для поддержки контейнерных типов. Предположим, имеется очередь типа Queue<int>, в которую нужно поместить содержимое любого другого контейнера (списка, вектора или обычного массива), причем его элементы имеют либо тип int (т.е. тот же, что у элементов очереди), либо приводимый к типу int. Шаблон-член assign()позволяет это сделать. Поскольку может быть использован любой контейнерный тип, то интерфейс assign() программируется в расчете на употребление итераторов; в результате реализация оказывается не зависящей от фактического типа, на который итераторы указывают.

В функции main() шаблон-член assign() сначала конкретизируется типом int*, что позволяет поместить в qi содержимое массива элементов типа int. Затем шаблон-член конкретизируется типом vector<int>::iterator – это дает возможность поместить в очередь qi содержимое вектора элементов типа int. Контейнер, содержимое которого помещается в очередь, не обязательно должен состоять из элементов типа int. Разрешен любой тип, который приводится к int. Чтобы понять, почему это так, еще раз посмотрим на определение assign():

template <class Iter>

      void assign( Iter first, Iter last )

{

   // удалить все элементы из очереди

   for ( ; first != last; ++first )

      add( *first );

}

Вызываемая из assign() функция add() – это функция-член Queue<Type>::add(). Если Queue конкретизируется типом int, то у add() будет следующий прототип:



void Queue<int>::add( const int &val );

Аргумент * first должен иметь тип int либо тип, которым можно инициализировать параметр-ссылку на const int. Преобразования типов допустимы. Например, если воспользоваться классом SmallInt из раздела 15.9, то содержимое контейнера, в котором хранятся элементы типа SmallInt, с помощью шаблона-члена assign() помещается в очередь типа Queue<int>. Это возможно потому, что в классе SmallInt имеется конвертер для приведения SmallInt к int:

class SmallInt {

public:

   SmallInt( int ival = 0 ) : value( ival ) { }

   // конвертер: SmallInt ==> int

   operator int() { return value; }

   // ...

private:

   int value;

};

int main()

{

   // конкретизация Queue<int>

   Queue<int> qi;

   vector<SmallInt> vsi;

   // заполнить вектор

   // конкретизация

   // Queue<int>::assign( vector<SmallInt>::iterator,

   //                     vector<SmallInt>::iterator )

   qi.assign( vsi.begin(), vsi.end() );

   list<int*> lpi;

   // заполнить список

   // ошибка при конкретизации шаблона-члена assign():

   // нет преобразования из int* в int

   qi.assign( lpi.begin(), lpi.end() );

}

Первая конкретизация assign() правильна, так как существует неявное преобразование из типа SmallInt в тип int и, следовательно, обращение к add() корректно. Вторая же конкретизация ошибочна: объект типа int* не может инициализировать ссылку на тип const int, поэтому вызвать функцию add() невозможно.

Для контейнерных типов из стандартной библиотеки C++ имеется функция assign(), которая ведет себя так же, как функция-шаблон assign() для нашего класса Queue.

Любую функцию-член можно задать в виде шаблона. Это относится, в частности, к конструктору. Например, для шаблона класса Queue его можно определить следующим образом:

template <class T>

class Queue {

   // ...

public:

   // шаблон-член конструктора

   template <class Iter>

   Queue( Iter first, Iter last )



        : front( 0 ), back( 0 )

   {

      for ( ; first != last; ++first )

          add( * first );

   }

};

Такой конструктор позволяет инициализировать очередь содержимым другого контейнера. У  контейнерных типов из стандартной библиотеки C++ также есть предназначенные для этой цели конструкторы в виде шаблонов-членов. Кстати, в первом (в данном разделе) определении функции main() использовался конструктор-шаблон для вектора:

vector<int> vi( ai, ai + 4 );

Это определение конкретизирует шаблон конструктора для контейнера vector<int> типом int*, что позволяет инициализировать вектор содержимым массива элементов типа int.

Шаблон-член, как и обычные члены, может быть определен вне определения объемлющего класса или шаблона класса. Так, являющиеся членами шаблон класса CL или шаблон функции assign() могут быть следующим образом определены вне шаблона Queue:

template <class T>

class Queue {

private:

   template <class Type> class CL;

   // ...

public:

   template <class Iter>

      void assign( Iter first, Iter last );

   // ...

};

template <class T> template <class Type>

   class Queue<T>::CL<Type>

{

   Type member;

   T mem;

};

template <class T> template <class Iter>

   void Queue<T>::assign( Iter first, Iter last )

{

   while ( ! is_empty() )

      remove();

   for ( ; first != last; ++first )

      add( *first );

}

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

template <class T> template <class Iter>

Первый список параметров шаблона template <class T> относится к шаблону класса Queue. Второй – к самому шаблону-члену assign(). Имена параметров не обязаны совпадать с теми, которые указаны внутри определения объемлющего шаблона класса. Приведенная инструкция по-прежнему определяет шаблон-член assign():

template <class TT> template <class IterType>

void Queue<TT>::assign( IterType first, IterType last )

{ ... }


Содержание раздела