Джесс Либерти - Освой самостоятельно С++ за 21 день.

Экземпляризация (instantiation) — это операция создания определенного типа из шаблона. Отдельные классы называются экземплярами шаблона.

Параметризованные шаблоны (parameterized templates) предоставляют возможность создания общего класса и для построения конкретных экземпляров передают этому классу в качестве параметров типы данных.

Объявляем параметризованный объект Array (шаблон для массива) путем записи следующих строк:

1: template // объявляем шаблон и параметр

2: class Array // параметризуемый класс

3: {

4: public:

5: Array();

6: // здесь должно быть полное определение класса

7: };

Ключевое слово template используется в начале каждого объявления и определения класса шаблона. Параметры шаблона располагаются за ключевым словом template. Параметры — это элементы, которые изменяются с каждым экземпляром. Например, в приведенном выше шаблоне массивов будет изменяться тип объектов, сохраняемых в массиве. Один экземпляр шаблона может хранить массив целых чисел, а другой — массив объектов класса Animals.

В этом примере используется ключевое слово class, за которым следует идентификатор Т. Это ключевое слово означает, что параметром является тип. Идентификатор T используется в остальной части определения шаблона, указывая тем самым на параметризованный тип. В одном экземпляре этого класса вместо идентификатора T повсюду будет стоять тип int, а в другом — тип Cat.

Чтобы объявить экземпляры параметризованного класса Array для типов int и Cat, следует написать:

Array anIntArray;

Array aCatArray;

Объект anIntArray представляет собой массив целых чисел, а объект aCatArray — массив элементов типа Cat. Теперь вы можете использовать тип Array в любом месте, где обычно указывается какой-либо тип — для возвращаемого функцией значения, для параметра функции и т.д. В листинге 19.1 содержится полное объявление уже рассмотренного нами шаблона Array.

Примечание: Программа в листинге 19.1 не завершена!

Листинг 19.1. Шаблон класса Array

1: //Листинг 19.1. Шаблон класса массивов

2: #include

3: const int DefaultSize = 10;

4:

5: template // объявляем шаблон и параметр

6: class Array // параметризуемый класс

7: {

8: public:

9: // конструкторы

10: Array(int itsSize = DefaultSize);

11: Array(const Array &rhs);

12: ~Array() { delete [] pType; }

13:

14: // операторы

15: Array& operator=(const Array&);

16: T& operator[](int offSet) { return pType[offSet]; }

17:

18: // методы доступа

19: int getSize() { return itsSize; }

20:

21: private:

22: T *pType;

23: int itsSize;

24: };

Результат:

Результатов нет. Эта программа не завершена.

Анализ:Определение шаблона начинается в строке 5 с ключевого слова template за которым следует параметр. В данном случае параметр идентифицируется как тип за счет использования ключевого слова class, а идентификатор T используется для представления параметризованного типа.

Со строки 6 и до конца определения шаблона (строка 24) вся остальная часть объявления аналогична любому другому объявлению класса. Единственное отличие заключается в том, что везде, где обычно должен стоять тип объекта, используется идентификатор T. Например, можно предположить, что operator[] должен возвращать ссылку на объект в массиве, а на самом деле он объявляется для возврата ссылки на идентификатор типа T.

Если объявлен экземпляр целочисленного массива, перегруженный оператор присваивания этого класса возвратит ссылку на тип integer. А при объявлении экземпляра массива Animal оператор присваивания возвратит ссылку на объект типа Animal.

Внутри объявления класса слово Array может использоваться без спецификаторов. В другом месте программы этот класс будет упоминаться как Array. Например, если не поместить конструктор внутри объявления класса, то вы должны записать следующее:

template

Array::Array(int size):

itsSize = size

{

pType = new T[size];

for (int i = 0; i

pType[i] = 0;

}

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

Array(int size).

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

Для выполнения класса шаблона Array необходимо создать конструктор-копировщик, перегрузить оператор присваивания (operator=) и т.д. В листинге 19.2 показана простая консольная программа, предназначенная для выполнения этого шаблона.

Примечание: Некоторые более старые компиляторы не поддерживают использование шаблонов. Но шаблоны являются частью стандарта ANSI C++, поэтому компиляторы всех основных производителей поддерживают шаблоны в своих текущих версиях. Если у вас очень старый компилятор, вы не сможете компилировать и выполнять упражнения, приведенные в этой главе. Однако все же стоит прочитать ее до конца, а затем вернуться к этому материалу после модернизации своего компилятора.

Листинг 19.2. Использвание шаблона массива

1: #include

2:

3: const int DefaultSize = 10;

4:

5: // обычный класс Animal для

6: // создания массива животных

7:

8: class Animal

9: {

10: public:

11: Animal(int);

12: Animal();

13: ~Animal() { }

14: int GetWeight() const { return itsWeight; }

15: void Display() const { cout << itsWeight; }

16: private:

17: int itsWeight;

18: };

19:

20: Animal::Animal(int weight):

21: itsWeight(weight)

22: { }

23:

24: Animal::Animal():

25: itsWeight(0)

26: { }

27:

28:

29: template // обьявляем шаблон и параметр

30: class Array // параметризованный класс

31: {

32: public:

33: // конструкторы

34: Array(int itsSize - DefaultSize);

35: Array(const Array &rhs);

36: ~Array() { delete [] pType; }

37:

38: // операторы

39: Array& operator=(const Array&);

40: T& operator[](int offSet) { return pType[offSet]; }

41: const T& operator[](int offSet) const

42: { return pType[offSet]; }

43: // методы доступа

44: int GetSize() const { return itsSize; }

45:

46: private:

47: T *рТуре;

48: int itsSize;

49: };

50:

51: // выполнения...

52:

53: // выполняем конструктор

54: template

55: Array::Array(int size):

56: itsSize(size)

57: {

58: pType = new T[size];

59: for (int i = 0; i

60: pType[i] = 0;

61: }

62:

63: // конструктор-копировщик

64: template

65: Array::Array(const Array &rhs)

66: {

67: itsSize = rhs.GetSize();

68: pType = new T[itsSize];

69: for (int i = 0; i

70: pType[i] = rhs[i];

71: }

72:

73: // оператор присваивания

74: template

75: Array& Array::operator=(const Array &rhs)

76: {

77: if (this == &rhs)

78: return *this;

79: delete [] pType;

80: itsSize = rhs.GetSize();

81: pType = new T[itsSize];

82: for (int i = 0; i

83: pType[i] = rhs[i];

84: return *this;

85: }

86:

87: // исполняемая программа

88: int main()

89: {

90: Array theArray; // массив целых

91: Array theZoo; // массив животных

92: Animal *pAnimal;

93:

94: // заполняем массивы

95: for (int i = 0; i < theArray.GetSize(); i++)

96: {

97: theArray[i] = i*2;