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

*** Intrude ***

i: 0

i: 2

i: 4

i: 6

i: 8

i: 10

i: 12

i: 14

i: 16

i: 18

Done.

Анализ:Объявление шаблона Array было расширено за счет включения дружественной функции Intrude(). Это объявление означает, что каждый экземпляр массива типа int будет считать функцию Intrude() дружественной, а следовательно, она будет иметь доступ к закрытым переменным-членам и функциям-членам экземпляра этого массива.

В строке 60 функция lntrude() непосредственно обращается к члену itsSize, а в строке 61 получает прямой доступ к переменной-члену pType. В данном случае без использования функции-друга можно было бы обойтись, поскольку класс Array предоставляет открытые методы доступа к этим данным. Этот листинг служит лишь примером того, как можно объявлять и использовать функции-друзья шаблонов.

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

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

ostream& operator<< (ostream&, Array&);

Чтобы этот оператор работал, нужно так объявить operator<<, чтобы он стал функцией шаблона:

template ostream& operator<< (ostream&, Array&)

Теперь operator<< является функцией шаблона и его можно использовать в выполнении класса. В листинге 19.4 показано объявление шаблона Array, дополненное объявлением функции оператора вывода operator<<.

Листинг 18.4. Использование оператора вывода

1: #include

2:

3: const int DefaultSize = 10;

4:

5: class Animal

6: {

7: public:

8: Animal(int);

9: Animal();

10: ~Animal() { }

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

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

13: private:

14: int itsWeight;

15: };

16:

17: Animal::Animal(int weight):

18: itsWeight(weight)

19: { }

20:

21: Animal::Animal():

22: itsWeight(0)

23: { }

24:

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

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

27: {

28: public:

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

30: Array(int itsSize = DefaultSize);

31: Array(const Array &rhs);

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

33:

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

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

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

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

38: { return pType[offSet]; }

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

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

41:

42: friend ostream& operator<< (ostream&, Array&);

43:

44: private:

45: T *pType;

46: int itsSize;

47: };

48:

49: template

50: ostream& operator<< (ostream& output, Array& theArray)

51: {

52: for (int i = 0; i

53: output << "[" << i << "] " << theArray[i] << endl; return output;

54: }

55:

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

57:

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

59: template

60: Array::Array(int size):

61: itsSize(size)

62: {

63: pType = new T[size];

64: for (int i = 0; i

65: pType[i] = 0;

66: }

67:

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

69: template

70: Array::Array(const Array &rhs)

71: {

72: itsSize = rhs.GetSize();

73: pType = new T[itsSize];

74: for (int i = 0; i

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

76: }

77:

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

79: template

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

81: {

82: if (this == &rhs)

83: return *this;

84: delete [] pType;

85: itsSize = rhs.GetSize();

86: pType = new T[itsSize];

87: for (int i = 0; i

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

89: return *this;

90: }

91:

92: int main()

93: {

94: bool Stop = false; // признак для цикла

95: int offset, value;

96: Array theArray;

97:

98: while (!Stop)

99: {

100: cout << "Enter an offset (0-9) ";

101: cout << "and a value. (-1 to stop): ";

102: cin >> offset >> value;

103:

104: if (offset < 0)

105: break;

106:

107: if (offset > 9)

108: {

109: cout << "***Please use values between 0 and 9.***\n";

110: continue;

111: }

112:

113: theArray[offset] = value;

114: }

115:

116: cout << "\nHere's the entire array:\n";

117: cout << theArray << endl;

118: return 0;

119: }

Результат:

Enter an offset (0 -9 and а value. (-1 to stop) 1 10

Enter an offset (0 -9 and а value. (-1 to stop) 2 20

Enter an offset (0 -9 and а value. (-1 to stop) 3 30

Enter an offset (0 -9 and а value. (-1 to stop) 4 40

Enter an offset (0 -9 and а value. (-1 to stop) 5 50

Enter an offset (0 -9 and а value. (-1 to stop) 6 60

Enter an offset (0 -9 and а value. (-1 to stop) 7 70

Enter an offset (0 -9 and а value. (-1 to stop) 8 80

Enter an offset (0 -9 and а value. (-1 to stop) 9 90

Enter an offset (0 -9 and а value. (-1 to stop) 1С 10

***Please use values between 0 and 9.* >>*

Enter an offset (0 -9) and а value. (-1 to stop) -1 -1

Here's the entire array:

[0] 0

[1] 10

[2] 20

[3] 30

[4] 40

[5] 50

[6] 60

[7] 70

[8] 80

[9] 90

Анализ:В строке 42 объявляется шаблон функции operator<<() в качестве друга шаблона класса Array. Поскольку operator<<() реализован в виде функции шаблона, то каждый экземпляр этого типа параметризованного массива будет автоматически иметь функцию operator<<() для вывода данных соответствующего типа. Выполнение этого оператора начинается в строке 49. Каждый член массива вызывается по очереди. Этот метод работает только в том случае, если функция operator<<() определена для каждого типа объекта, сохраняемого в массиве.

С экземплярами шаблона можно обращаться так же, как с любыми другими типами данных. Их можно передавать в функции как ссылки или как значения и возвращать как результат выполнения функции (тоже как ссылки или как значения). Способы передачи экземпляров шаблона показаны в листинге 19.5.

Листинг 19.5. Передача в функцию экземпляра шаблона

1: #include

2:

3: const int DefaultSize = 10;

4:

5: // Обычный класс, из объектов которого будет состоять массив

6: class Animal

7: {

8: public:

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

10: Animal(int);

11: Animal();

12: ~Animal();

13:

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

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

16: void SetWeight(int theWeight) { itsWeight = theWeight; }

17:

18: // дружественные операторы

19: friend ostream& operator<< (ostream&, const Animal&);

20:

21: private:

22: int itsWeight;

23: };

24:

25: // оператор вывода объектов типа Animal

26: ostream& operator<<

27: (ostream& theStream, const Animal& theAnimal)

28: {

29: theStream << theAnimal.GetWeight();

30: return theStream;

31: }

32:

33: Animal::Animal(int weight):

34: itsWeight(weight)

35: {

36: // cout << "Animal(int)\n";

37: }

38:

39: Animal::Animal():

40: itsWeight(0)

41: {

42: // cout << "Animal()\n";

43: }

44:

45: Animal::~Animal()

46: {

47: // cout << "Destroyed an animal...\n";

48: }

49:

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

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

52: {

53: public:

54: Array(int itsSlze = DefaultSize);

55: Array(const Array &rhs);

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

57:

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

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

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

61: { return pType[offSet]; }

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

63:

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

65: friend ostream& operator<< (ostream&, const Array&);

66:

67: private:

68: T *рТуре;

69: int itsSize;

70: };

71:

70: template

72: ostream& operator<< (ostream& output, const Array& theArray)

73: {

74: for (int i = 0; i

75: output << "[" << i << "] " << theArray[i] << endl;

76: return output;

77: }

78:

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

80:

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

82: template

83: Array::Array(int size):

84: itsSize(size)

85: {

86: рТуре = new T[size];

67: for (int i = 0; i

88: pType[i] = 0;

89: }

90:

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

92: template

93: Array::Array(const Array &rhs)

94: {

95: itsSize = rhs.GetSize();

96: рТуре = new T[itsSize];

97: for (int i = 0; i

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