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

98: pAnimal = new Animal(i*3);

99: theZoo[i] = *pAnimal;

100: delete pAnimal;

101: }

102: // выводим на печать содержимое массивов

103: for (int j = 0; j < theArray.GetSize(); j++)

104: {

105: cout << "theArray[" << j << "]:\t";

106: cout << theArray[j] << "\t\t";

107: cout << "theZoo[" << j << "]:\t";

108: theZoo[j].Display();

109: cout << endl;

110: }

111:

112: return 0;

113: }

Результат:

theArray[0] 0 theZoo[0] 0

theArray[1] 2 theZoo[1] 3

theArray[2] 4 theZoo[2] - 6

theArray[3] 6 theZoo[3] 9

theArray[4] 8 theZoo[4] 12

theArray[5] 10 theZoo[5] 15

theArray[6] 12 theZoo[6] 18

theArray[7] 14 theZoo[7] 21

theArray[8] 16 theZoo[8] 24

theArray[9] 18 theZoo[9] 27

Анализ:В строках 8-26 выполняется создание класса Animal, благодаря которому объекты определяемого пользователем типа можно будет добавлять в массив.

Содержимое строки 29 означает, что в следующих за ней строках объявляется шаблон, параметром для которого является тип, обозначенный идентификатором Т. Класс Array содержит два конструктора, причем первый конструктор принимает размер и по умолчанию устанавливает его равным значению целочисленной константы DefaultSize.

Затем объявляются операторы присваивания и индексирования, причем объявляются константная и не константная версии оператора индексирования. В качестве единственного метода доступа служит функция GetSize(), которая возвращает размер массива.

Можно, конечно, представить себе и более полный интерфейс. Ведь для любой серьезной программы создания массива представленный здесь вариант будет недостаточным. Как минимум, пришлось бы добавить операторы, предназначенные для удаления элементов, для распаковки и упаковки массива и т.д. Все это предусмотрено классами контейнеров библиотеки STL, но к этому мы вернемся в конце занятия.

Раздел закрытых данных содержит переменные-члены размера массива и указатель на массив объектов, реально помещенных в память.

Если вы хотите передать функции объект массива, нужно передавать конкретный экземпляр массива, а не шаблон. Поэтому, если некоторая функция SomeFunction() принимает в качестве параметра целочисленный массив, используйте следующую запись:

void SomeFunction(Array&); // правильно

А запись

void SomeFunction(Array&); // ошибка!

неверна, поскольку отсюда не ясно, что представляет собой выражение T&. Запись

void SomeFunction(Array &); // ошибка!

тоже ошибочна, так как объекта класса Array не существует — есть только шаблон и его экземпляры.

Чтобы реализовать более общий подход использования объектов, созданных на основе шаблона, нужно объявить функцию шаблона:

template

void MyTemplateFunction(Array&); // верно

Здесь MyTemplateFunction() объявлена как функция шаблона, на что указывает первая строка объявления. Заметьте, что функции шаблонов, подобно другим функциям, могут иметь любые имена.

Функции шаблонов, помимо объектов, заданных в параметризованной форме, могут также принимать и экземпляры шаблона. Проиллюстрируем это на примере:

template

void MyOtherFunction(Array&, Array&); // верно

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

В шаблонах классов могут быть объявлены три типа друзей:

• дружественный класс или функция, не являющиеся шаблоном;

• дружественный шаблон класса или функция, входящая в шаблон;

• дружественный шаблон класса или шаблонная функция, специализированные по типу данных.

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

Листинг 18.3. Функция-друг, не являющаяся шаблоном

1: // Листинг 19.3. Использование в шаблонах функций-друзей определенного типа

2:

3: #include

4:

5: const int DefaultSize = 10;

6:

7: // обьявляем простой класс Animal, чтобы можно

8: // было создать массив животных

9:

10: class Animal

11: {

12: public:

13: Animal(int);

14: Animal();

15: ~Animal() { }

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

17: void Display() const { cout << itsWeight; >

18: private:

19: int itsWeight;

20: };

21:

22: Animal::Animal(intweight):

23: itsWeight(weight)

24: { }

25:

26: Animal::Animal():

27: itsWeight(0)

28: { }

29:

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

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

32: {

33: public:

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

35: Array(int itsSize = DefaultSize);

36: Array(const Array &rhs);

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

38:

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

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

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

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

43: { return pType[offSet]; }

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

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

46:

47: // функция-друг

48: friend void Intrude(Array);

49

50: private:

51: T *рТуре;

52: int itsSize;

53: };

54:

55: // Поскольку функция-друг не является шаблоном, ее можно использовать только

56: // с массивами целых чисел! Но она получает доступ к закрытым данным класса.

57: void Intrude(Array theArray)

58: {

59: cout << "\n*** Intrude ***\n";

60: for (int i = 0; i < theArray.itsSize; i++)

61: cout << "i: " << theArray.pType[i] << endl;

62: cout << "\n"

63: }

64:

65: // Ряд выполнений...

66:

67: // выполнение конструктора

68: template

69: Array::Array(int size):

70: itsSize(size)

71: {

72: pType = new T[size];

73: for (int i = 0; i

74: pType[i] = 0;

75: }

76:

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

78: template

79: Array::Array(const Array &rhs)

80: {

81: itsSize = rhs.GetSize();

82: pType = new T[itsSize];

83: for (int i = 0; i

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

85: }

86:

87: // перегрузка оператора присваивания (=)

88: template

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

90: {

91: if (this == &rhs)

92: return *this;

93: delete [] pType;

94: itsSize = rhs.GetSize();

95: pType = new T[itsSize];

96: for (int i = 0; i

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

98: return *this;

99: }

100:

101: // управляющая программа

102: int main()

103: {

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

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

106: Animal *pAnimal;

107:

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

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

110: {

111: theArray[i] = i*2;

112: pAnimal = new Animal(i*3);

113: theZoo[i] = *pAnimal;

114: }

115:

116: int j;

117: for (j = 0; j < theArray.GetSize(); j++)

118: {

119: cout << "theZoo[" << j << "]:\t";

120: theZoo[j].Display();

121: cout << endl;

122: }

123: cout << "Now use the friend function to";

124: cout << "find the members of Array";

125: Intrude(theArray);

126:

127: cout << "\n\nDone.\n";

128: return 0;

129: }

Результат:

theZoo[0]: 0

theZoo[1]: 3

theZoo[2]: 6

theZoo[3]: 9

theZoo[4]: 12

theZoo[5]: 15

theZoo[6]: 18

theZoo[7]: 21

theZoo[8]: 24

theZoo[9]: 27

Now use the friend function to find the members of Array