16.2. Конкретизация шаблона класса

extern Queue<double> eqd; Queue<int> *pqi = new Queue<int>; Queue<int> aqi[1024];

int main() { int ix;

if ( ! pqi->is_empty() )

ix = pqi->remove();

//...

for ( ix = 0; ix < 1024; + +ix )

eqd[ ix ].add( ix ); // ...

}

В объявлении и определении шаблона можно ссылаться как на сам шаблон, так и на

// объявление шаблона функции template <class Type>

конкретизированный по нему класс:

)

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

void foo( Queue<int> &qi )

{

Queue<int> *pq = &qi; // ...

шаблона Queue:

}

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

class Matrix;

Matrix *pm; // правильно: определение класса Matrix знать необязательно

класс его знать необязательно:

void inverse( Matrix & ); // тоже правильно

Поэтому объявление указателей и ссылок на конкретизированный шаблон класса не приводит к его конкретизации. (Отметим, что в некоторых компиляторах, написанных до принятия стандарта C++, шаблон конкретизируется при первом упоминании имени

конкретизированного класса в тексте программы.) Так, в функции foo() объявляются

// Queue<int> не конкретизируется при таком использовании в foo()

void foo( Queue<int> &qi )

{

Queue<int> *pqi = &qi; // ...

указатель и ссылка на Queue<int>, но это не вызывает конкретизации шаблона Queue:

}

Определение класса необходимо знать, когда определяется объект этого типа. В следующем примере определение obj1 ошибочно: чтобы выделить для него память,

class Matrix;

Matrix obj1; // ошибка: класс Matrix не определен

class Matrix { ... };

компилятору необходимо знать размер класса Matrix:

Matrix obj2; // правильно

Таким образом, конкретизация происходит тогда, когда определяется объект класса, конкретизированного по этому шаблону. В следующем примере определение объекта qi приводит к конкретизации шаблона Queue<int>:

Queue<int> qi; // конкретизируется Queue<int>

Определение Queue<int> становится известно компилятору именно в этой точке, которая называется точкой конкретизации данного класса.

Если имеется указатель или ссылка на конкретизированный шаблон, то конкретизация также производится в момент обращения к объекту, на который они ссылаются. В определенной выше функции foo() класс Queue<int> конкретизируется в следующих случаях: когда разыменовывается указатель pqi, когда ссылка qi используется для получения значения именуемого объекта и когда pqi или qi употребляются для доступа

void foo( Queue<int> &qi )

{

Queue<int> *pqi = &qi;

// Queue<int> конкретизируется в результате вызова функциичлена

pqi->add( 255 );

//...

кчленам или функциям-членам этого класса:

}

Определение Queue<int> становится известным компилятору еще до вызова функциичлена add() из foo().

Напомним, что в определении шаблона класса Queue есть также ссылка на шаблон

template <class Type> class Queue { public:

// ...

private:

QueueItem<Type>

*front; QueueItem<Type> *back;

QueueItem:

};

При конкретизации Queue типом int члены front и back становятся указателями на QueueItem<int>. Следовательно, конкретизированный экземпляр Queue<int> ссылается на экземпляр QueueItem, конкретизированный типом int. Но поскольку соответствующие члены являются указателями, то QueueItem<int> конкретизируется лишь в момент их разыменования в функциях-членах класса Queue<int>.

Наш класс QueueItem служит вспомогательным средством для реализации класса Queue и не будет непосредственно употребляться в вызывающей программе. Поэтому пользовательская программа способна манипулировать только объектами Queue. Конкретизация шаблона QueueItem происходит лишь в момент конкретизации шаблона класса Queue или его членов. (В следующих разделах мы рассмотрим конкретизации членов шаблона класса.)

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

template <class Type> class QueueItem { public:

QueueItem( Type ); // неудачное проектное решение

// ...

вида?

};

В данном определении аргумент передается по значению. Это допустимо, если QueueItem конкретизируется встроенным типом (например, QueueItem<int>). Но если такая конкретизация производится для объемного типа (скажем, Matrix), то накладные расходы, вызванные неправильным выбором на этапе проектирования, становятся неприемлемыми. (В разделе 7.3 обсуждались вопросы производительности, связанные с передачей параметров по значению и по ссылке.) Поэтому аргумент конструктора объявляется как ссылка на константный тип:

QueueItem( const Type & );

Следующее определение приемлемо, если у типа, для которого конкретизируется QueueItem, нет ассоциированного конструктора: