<< Пред.           стр. 74 (из 121)           След. >>

Список литературы по разделу

 Такое имя разрешается повторно использовать в объявлениях или определениях других шаблонов:
 // правильно: повторное использование имени Type в разных шаблонах
 template
  class QueueItem;
 
 template
  class Queue;
 Имена параметров в опережающем объявлении и последующем определении одного и того же шаблона не обязаны совпадать. Например, все эти объявления QueueItem относятся к одному шаблону класса:
 // все три объявления QueueItem
 // относятся к одному и тому же шаблону класса
 
 // объявления шаблона
 template class QueueItem;
 template class QueueItem;
 
 // фактическое определение шаблона
 template
  class QueueItem { ... };
 У параметров могут быть аргументы по умолчанию (это справедливо как для параметров-типов, так и для параметров-констант) – тип или значение, которые используются в том случае, когда при конкретизации шаблона фактический аргумент не указан. В качестве такого аргумента следует выбирать тип или значение, подходящее для большинства конкретизаций. Например, если при конкретизации шаблона класса Buffer не указан размер буфера, то по умолчанию принимается 1024:
 template
  class Buffer;
 В последующих объявлениях шаблона могут быть заданы дополнительные аргументы по умолчанию. Как и в объявлениях функций, если для некоторого параметра задан такой аргумент, то он должен быть задан и для всех параметров, расположенных в списке правее (даже в другом объявлении того же шаблона):
 template
  class Buffer;
 // правильно: рассматриваются аргументы по умолчанию из обоих объявлений
 template
  class Buffer;
 (Отметим, что аргументы по умолчанию для параметров шаблонов не поддерживаются в компиляторах, реализованных до принятия стандарта C++. Чтобы примеры из этой книги, в частности из главы 12, компилировались большинством современных компиляторов, мы не использовали такие аргументы.)
 Внутри определения шаблона его имя можно применять как спецификатор типа всюду, где допустимо употребление имени обычного класса. Вот более полная версия определения шаблона QueueItem:
 template
 class QueueItem {
 public:
  QueueItem( const Type & );
 private:
  Type item;
  QueueItem *next;
 };
 Обратите внимание, что каждое появление имени QueueItem в определении шаблона – это сокращенная запись для
 QueueItem
 Такую сокращенную нотацию можно употреблять только внутри определения QueueItem (и, как мы покажем в следующих разделах, в определениях его членов, которые находятся вне определения шаблона класса). Если QueueItem применяется как спецификатор типа в определении какого-либо другого шаблона, то необходимо задавать полный список параметров. В следующем примере шаблон класса используется в определении шаблона функции display. Здесь за именем шаблона класса QueueItem должны идти параметры, т.е. QueueItem.
 template
 void display( QueueItem &qi )
 {
  QueueItem *pqi = &qi;
  // ...
 }
 16.1.1. Определения шаблонов классов Queue и QueueItem
 Ниже представлено определение шаблона класса Queue. Оно помещено в заголовочный файл Queue.h вместе с определением шаблона QueueItem:
 #ifndef QUEUE_H
 #define QUEUE_H
 
 // объявление QueueItem
 template class QueueItem;
 
 template
 class Queue {
 public:
  Queue() : front( 0 ), back ( 0 ) { }
  ~Queue();
 
  Type& remove();
  void add( const Type & );
  bool is_empty() const {
  return front == 0;
  }
 private:
  QueueItem *front;
  QueueItem *back;
 };
 #endif
 При использовании имени Queue внутри определения шаблона класса Queue список параметров можно опускать. Однако пропуск списка параметров шаблона QueueItem в определении шаблона Queue недопустим. Так, объявление члена front является ошибкой:
 template
 class Queue {
 public:
  // ...
 private:
  // ошибка: список параметров для QueueItem неизвестен
  QueueItem *front;
 }
 Упражнение 16.1
 Найдите ошибочные объявления (или пары объявлений) шаблонов классов:
 (a) template
  class Container1;
 
  template
  class Container1;
 (b) template
  class Container2;
 (c) template
  class Container3 {};
 (d) template
  class Container4 {};
 (e) template
  class Container5;
 (f) template
  class Container6;
  template , int v>
  class Container6;
 Упражнение 16.2
 Следующее определение шаблона List некорректно. Как исправить ошибку?
 template
 class ListItem;
 
 template
 class List {
 public:
  List()
  : _at_front( 0 ), _at_end( 0 ), _current( 0 ), _size( 0 )
  {}
  List( const List & );
  List& operator=( const List & );
 
  ~List();
 
  void insert( ListItem *ptr, elemType value );
  int remove( elemType value );
 
  ListItem *find( elemType value );
 
  void display( ostream &os = cout );
  int size() { return _size; }
 private:
  ListItem *_at_front;
  ListItem *_at_end;
  ListItem *_current;
  int _size
 };
 16.2. Конкретизация шаблона класса
 В определении шаблона указывается, как следует строить индивидуальные классы, если заданы один или более фактических типов или значений. По шаблону Queue автоматически генерируются экземпляры классов Queue с разными типами элементов. Например, если написать:
 Queue qi;
 то из обобщенного определения шаблона автоматически создается класс Queue для объектов типа int.
 Генерация конкретного класса из обобщенного определения шаблона называется конкретизацией шаблона. При такой конкретизации Queue для объектов типа int каждое вхождение параметра Type в определении шаблона заменяется на int, так что определение класса Queue принимает вид:
 template
 class Queue {
 public:
  Queue() : front( 0 ), back ( 0 ) { }
  ~Queue();
 
  int& remove();
  void add( const int & );
  bool is_empty() const {
  return front == 0;
  }
 private:
  QueueItem *front;
  QueueItem *back;
 };
 Чтобы создать класс Queue для объектов типа string, надо написать:
 Queue qs;
 При этом каждое вхождение Type в определении шаблона будет заменено на string. Объекты qi и qs являются объектами автоматически созданных классов.
 Каждый конкретизированный по одному и тому же шаблону экземпляр класса совершенно не зависит от всех остальных. Так, у Queue для типа int нет никаких прав доступа к неоткрытым членам того же класса для типа string.
 Конкретизированный экземпляр шаблона будет иметь соответственно имя Queue или Queue. Части и , следующие за именем Queue, называются фактическими аргументами шаблона. Они должны быть заключены в угловые скобки и отделяться друг от друга запятыми. В имени конкретизируемого шаблона аргументы всегда должны задаваться явно. В отличие от аргументов шаблона функции, аргументы шаблона класса никогда не выводятся из контекста:
 Queue qs; // ошибка: как конкретизируется шаблон?
 Конкретизированный шаблон класса Queue можно использовать в программе всюду, где допустимо употребление типа обычного класса:
 // типы возвращаемого значения и обоих параметров конкретизированы из
 // шаблона класса Queue
 extern Queue< complex >
  foo( Queue< complex > &, Queue< complex > & );
 
 // указатель на функцию-член класса, конкретизированного из шаблона Queue
 bool (Queue::*pmf)() = 0;
 
 // явное приведение 0 к указателю на экземпляр Queue
 Queue *pqc = static_cast< Queue* > ( 0 );
 Объекты типа класса, конкретизированного по шаблону Queue, объявляются и используются так же, как объекты обычных классов:
 extern Queue eqd;
 Queue *pqi = new Queue;
 Queue aqi[1024];
 
 int main() {
  int ix;
  if ( ! pqi->is_empty() )
  ix = pqi->remove();
  // ...
  for ( ix = 0; ix < 1024; ++ix )
  eqd[ ix ].add( ix );
  // ...
 }
 В объявлении и определении шаблона можно ссылаться как на сам шаблон, так и на конкретизированный по нему класс:
 // объявление шаблона функции
 template
 void bar( Queue &, // ссылается на обобщенный шаблон
  Queue & // ссылается на конкретизированный шаблон
 )
 Однако вне такого определения употребляются только конкретизированные экземпляры. Например, в теле обычной функции всегда надо задавать фактические аргументы шаблона Queue:
 void foo( Queue &qi )
 {
  Queue *pq = &qi;
  // ...
 }
 Шаблон класса конкретизируется только тогда, когда имя полученного экземпляра употребляется в контексте, где требуется определение шаблона. Не всегда определение класса должно быть известно. Например, перед объявлением указателей и ссылок на класс его знать необязательно:
 class Matrix;
 Matrix *pm; // правильно: определение класса Matrix знать необязательно
 
 void inverse( Matrix & ); // тоже правильно
 Поэтому объявление указателей и ссылок на конкретизированный шаблон класса не приводит к его конкретизации. (Отметим, что в некоторых компиляторах, написанных до принятия стандарта C++, шаблон конкретизируется при первом упоминании имени конкретизированного класса в тексте программы.) Так, в функции foo() объявляются указатель и ссылка на Queue, но это не вызывает конкретизации шаблона Queue:
 // Queue не конкретизируется при таком использовании в foo()
 void foo( Queue &qi )
 {
  Queue *pqi = &qi;
  // ...
 }
 Определение класса необходимо знать, когда определяется объект этого типа. В следующем примере определение obj1 ошибочно: чтобы выделить для него память, компилятору необходимо знать размер класса Matrix:
 class Matrix;
 Matrix obj1; // ошибка: класс Matrix не определен
 class Matrix { ... };
 Matrix obj2; // правильно
 Таким образом, конкретизация происходит тогда, когда определяется объект класса, конкретизированного по этому шаблону. В следующем примере определение объекта qi приводит к конкретизации шаблона Queue:
 Queue qi; // конкретизируется Queue
 Определение Queue становится известно компилятору именно в этой точке, которая называется точкой конкретизации данного класса.
 Если имеется указатель или ссылка на конкретизированный шаблон, то конкретизация также производится в момент обращения к объекту, на который они ссылаются. В определенной выше функции foo() класс Queue конкретизируется в следующих случаях: когда разыменовывается указатель pqi, когда ссылка qi используется для получения значения именуемого объекта и когда pqi или qi употребляются для доступа к членам или функциям-членам этого класса:
 void foo( Queue &qi )
 {
  Queue *pqi = &qi;
 
  // Queue конкретизируется в результате вызова функции-члена
  pqi->add( 255 );
  // ...
 }
 Определение Queue становится известным компилятору еще до вызова функции-члена add() из foo().
 Напомним, что в определении шаблона класса Queue есть также ссылка на шаблон QueueItem:
 template
 class Queue {
 public:
  // ...
 private:
  QueueItem *front;
  QueueItem *back;
 };
 При конкретизации Queue типом int члены front и back становятся указателями на QueueItem. Следовательно, конкретизированный экземпляр Queue ссылается на экземпляр QueueItem, конкретизированный типом int. Но поскольку соответствующие члены являются указателями, то QueueItem конкретизируется лишь в момент их разыменования в функциях-членах класса Queue.
 Наш класс QueueItem служит вспомогательным средством для реализации класса Queue и не будет непосредственно употребляться в вызывающей программе. Поэтому пользовательская программа способна манипулировать только объектами Queue. Конкретизация шаблона QueueItem происходит лишь в момент конкретизации шаблона класса Queue или его членов. (В следующих разделах мы рассмотрим конкретизации членов шаблона класса.)
 В зависимости от типов, которыми может конкретизироваться шаблон, при его определении надо учитывать некоторые нюансы. Почему, например, следующее определение конструктора класса QueueItem не подходит для конкретизации общего вида?
 template
 class QueueItem {
 public:
  QueueItem( Type ); // неудачное проектное решение
  // ...
 };
 В данном определении аргумент передается по значению. Это допустимо, если QueueItem конкретизируется встроенным типом (например, QueueItem). Но если такая конкретизация производится для объемного типа (скажем, Matrix), то накладные расходы, вызванные неправильным выбором на этапе проектирования, становятся неприемлемыми. (В разделе 7.3 обсуждались вопросы производительности, связанные с передачей параметров по значению и по ссылке.) Поэтому аргумент конструктора объявляется как ссылка на константный тип:
 QueueItem( const Type & );
 Следующее определение приемлемо, если у типа, для которого конкретизируется QueueItem, нет ассоциированного конструктора:
 template
 class QueueItem {
  // ...
 public:
  // потенциально неэффективно
  QueueItem( const Type &t ) {
  item = t; next = 0;
  }
 };
 Если аргументом шаблона является тип класса с конструктором (например, string), то item инициализируется дважды! Конструктор по умолчанию string вызывается для инициализации item перед выполнением тела конструктора QueueItem. Затем для созданного объекта item производится почленное присваивание. Избежать такого можно с помощью явной инициализации item в списке инициализации членов внутри определения конструктора QueueItem:
 template
 class QueueItem {
  // ...
 public:
  // item инициализируется в списке инициализации членов конструктора
  QueueItem( const Type &t )
  : item(t) { next = 0; }
 };
 (Списки инициализации членов и основания для их применения обсуждались в разделе 14.5.)
 16.2.1. Аргументы шаблона для параметров-констант
 Параметр шаблона класса может и не быть типом. На аргументы, подставляемые вместо таких параметров, накладываются некоторые ограничения. В следующем примере мы изменяем определение класса Screen (см. главу 13) на шаблон, параметризованный высотой и шириной:
 template
 class Screen {
 public:
  Screen() : _height( hi ), _width( wid ), _cursor ( 0 ),
  _screen( hi * wid, '#' )
  { }
  // ...
 private:
  string _screen;
  string::size_type _cursor;
  short _height;
  short _width;
 };
 
 typedef Screen<24,80> termScreen;
 termScreen hp2621;
 
 Screen<8,24> ancientScreen;
 Выражение, с которым связан параметр, не являющийся типом, должно быть константным, т.е. вычисляемым во время компиляции. В примере выше typedef termScreen ссылается на экземпляр шаблона Screen<24,80>, где аргумент шаблона для hi равен 24, а для wid – 80. В обоих случаях аргумент – это константное выражение.
 Однако для шаблона BufPtr конкретизация приводит к ошибке, так как значение указателя, получающееся при вызове оператора new(), становится известно только во время выполнения:
 template class BufPtr { ... };
 
 // ошибка: аргумент шаблона нельзя вычислить во время компиляции
 BufPtr< new int[24] > bp;
 Не является константным выражением и значение неконстантного объекта. Его нельзя использовать в качестве аргумента для параметра-константы шаблона. Однако адрес любого объекта в области видимости пространства имен, в отличие от адреса локального объекта, является константным выражением (даже если спецификатор const отсутствует), поэтому его можно применять в качестве аргумента для параметра-константы. Константным выражением будет и значение оператора sizeof:
 template Buf { ... };
 template class BufPtr { ... };
 
 int size_val = 1024;
 const int c_size_val = 1024;
 
 Buf< 1024 > buf0; // правильно
 Buf< c_size_val > buf1; // правильно
 Buf< sizeof(size_val) > buf2; // правильно: sizeof(int)
 BufPtr< &size_val > bp0; // правильно
 
 // ошибка: нельзя вычислить во время компиляции
 Buf< size_val > buf3;

<< Пред.           стр. 74 (из 121)           След. >>

Список литературы по разделу