Имя_параиетризованного_класса

<фактические_параметры_шаблона> имя_объекта (паракетры_конструктора) ;

В нашем случае определить вектор, имеющий восемь вещественных координат типа double, можно следующим образом:

Vector <double> Z(8); Проиллюстрируем сказанное следующей программой:

#include "templatevec.h" // Шаблон классов "вектор"

#include <iostream.h>

main(){ // Создаем объект класса "целочисленный вектор":

Vector <int> Х(5);

// Создаем объект класса "символьный вектор":

Vector <char> C(5);

// Определяем компоненты векторов:

for (int i = 0; i < 5; i++) { X[i] = i; C[i] = 'A' + i;}

for (i - 0; i < 5 ; i++) cout << " " << X[i] << ' ' << C[i]; }

Результат выполнения программы:

0 A 1 B 2 С 3 D 4 E

В программе шаблон семейства классов с общим именем vector используется для формирования двух классов с массивами целого и символьного типов. В соответствии с требованием синтаксиса имя параметризованного класса, определенное в шаблоне (в примере Vector), используется в программе только с последующим конкретным фактическим параметром (аргументом), заключенным в угловые скобки. Параметром может быть имя стандартного или определенного пользователем типа. В данном примере использованы стандартные типы int и char. Использовать имя Vector без указания фактического параметра шаблона нельзя - никакое умалчиваемое значение при этом не предусматривается.

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

#include <iostream.h>

template <class T, int size = 64>

class row {

T *data;

Int length;

public: row() { length = size; data = new T[size]; }

~row() { deleted data; }

T& operator [] (int i) { return data[i]; }

};

Void main () {

row <float,8> rf;

row <int,8> ri;

for (int i = 0; i < 8; i++) { rf[i] = i; ri[i] = i * i; }

for (i = 0; i < 8; i++) cout<<« " " << rf[i] << ' ' << ri[i];

}

Результат выполнения программы:

0 0 1 1 2 4 3 9 4 16 5 25 6 36 7 49

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

// class Matr

//-------------------------------------------------------------------

template <class T >

class Matr

{

long line;

long col;

T ** matr;

public:

virtual ~Matr(); //Деструктор

Matr(long l, long c); // Конструктор

Matr():line(0), col(0),matr(NULL){} //Конструктор по умолчанию

Matr(Matr<T >& A); //Конструктор копии

T * operator[](long i){return matr[i];}

template <class T>

friend Matr<T > operator*( Matr<T >& A, Matr<T >& B);

const Matr<T >& operator=(const Matr<T >& A);

template <class T>

friend Matr<T > operator*(double K, const Matr<T >& A);

Matr<T > operator+(const Matr<T >& A);

Matr<T > operator-(const Matr<T >& A);

void display();

};

// Matr<T >::Matr()

//-------------------------------------------------------------------

template <class T >

Matr<T >::Matr(long l1, long col1)

{

line = l1;

col = col1;

matr = new T *[line];

if(matr == NULL) cout<< "Out of memory";

for (int i = 0; i < line; i++){

matr[i] = new T [col];

if(matr[i] == NULL) cout<<"Out of memory";

}

}

// Matr<T >::Matr(Matr<T >& A)

//-------------------------------------------------------------------

template <class T >

Matr<T >::Matr(Matr<T >& A):line(A.line), col(A.col)

{

matr = new T *[line];

int i;

if(matr == NULL) cout<< "Out of memory";

for (i = 0; i < line; i++){

matr[i] = new T [col];

if(matr[i] == NULL) cout<<"Out of memory";

}

for(long j = 0; j<line; j++){

for( i = 0; i<col; i++){

matr[j][i] = A.matr[j][i];

}

}

}

// Matr<T >::~Matr()

//-------------------------------------------------------------------

template <class T >

Matr<T >::~Matr()

{

for (int i = 0; i < line; i++) delete matr[i];

delete matr;

}

// void display(const Matr<T >& A)

//-------------------------------------------------------------------

template <class T >

void Matr<T >::display(){

cout<<"\n";

for(int i = 0; i<line;i++){

cout<<"\n";

for(int j = 0; j < col; j++)

cout<<matr[i][j]<<"\t";

}

}

// Matr<T >::operator*()

//-------------------------------------------------------------------

template <class T >

Matr<T > operator*( Matr<T >& A,

Matr<T >& B)

{

if(!(A.col == B.line)) cout<<"\n A*B A.col != B.line";

Matr<T > arMatr(A.line, B.col);

long l1 = A.line;

long col1 = A.col;

long col2 = B.col;

for(long i = 0; i < l1; i++){

for(long j = 0; j < col2; j++){

arMatr[i][j] = 0;

for(long k = 0; k < col1; k++) {

arMatr[i][j]+=A[i][k]*B[k][j];

}

}

}

return arMatr;

}

// Matr::operator=()

//-------------------------------------------------------------------

template <class T >

const Matr<T >& Matr<T >::operator=(const Matr<T >& A)

{

if(this == &A) return *this;

line = A.line;

col = A.col;

for(long i = 0; i<A.line; i++){

for(long j = 0; j<A.col; j++){

matr[i][j] = A.matr[i][j];

}

}

return *this;

}

// Matr<T >::operator*()

//-------------------------------------------------------------------

template <class T >

Matr<T > operator*(double K, const Matr<T >& A)

{

Matr<T > M(A.line, A.col);

for(long i = 0; i<A.line; i++){

for(long j = 0; j<A.col; j++){

M.matr[i][j] = K * A.matr[i][j];

}

}

return M;

}

// Matr<T >::operator+()

//-------------------------------------------------------------------

template <class T >

Matr<T > Matr<T >::operator+(const Matr<T >& A)

{

if(line != A.line || col != A.col) {

cout<<"\n A != B";

Matr<T > M(0,0);

return M;

}

Matr<T > M(A.line, A.col);

for(long i = 0; i<A.line; i++){

for(long j = 0; j<A.col; j++){

M.matr[i][j] = matr[i][j] + A.matr[i][j];

}

}

return M;

}

// Matr<T >::operator-()

//-------------------------------------------------------------------

template <class T >

Matr<T > Matr<T >::operator-(const Matr<T >& A)

{

if(line != A.line) {

cout<<"\n - no A.line = B.line";

Matr<T > M(0,0);

return M;

}

if(col != A.col) {

cout<<"\n - no A.line = B.line";

Matr<T > M(0,0);

return M;

}

Matr<T > M(A.line, A.col);

for(long i = 0; i<A.line; i++){

for(long j = 0; j<A.col; j++){

M.matr[i][j] = matr[i][j] - A.matr[i][j];

}

}

return M;

}

// TMatr()

//-------------------------------------------------------------------

template <class T >

Matr<T > TMatr(Matr<T >& M){

Matr<T > TM(M.col, M.line);

for(int i = 0; i < M.line; i++)

for(int j = 0; j < M.col; j++)

TM[j][i] = M[i][j];

return TM;

}

void main(){

Matr<double> A(2,2), B(2,2);

A[0][0]=A[0][1]=A[1][0]=A[1][1] = 1;

B[0][0]=B[0][1]=B[1][0]=B[1][1] = 2;

A.display();

B.display();

A=(2.5*A-A+B)*B;

A.display();

getchar();

}