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

⇐ ПредыдущаяСтр 71 из 85Следующая ⇒

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

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

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

3: #include < iostream.h>

5: const int DefaultSize = 10;

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

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

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 < class T> // обьявляем шаблон и параметр

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< int> );

50: private:

51: T *рТуре;

52: int itsSize;

53: };

54:

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

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

57: void Intrude(Array< int> 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 < class T>

69: Array< T>:: Array(int size):

70: itsSize(size)

71: {

72: pType = new T[size];

73: for (int i = 0; i< size; i++)

74: pType[i] = 0;

75: }

76:

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

78: template < class T>

79: Array< T>:: Array(const Array & rhs)

80: {

81: itsSize = rhs.GetSize();

82: pType = new T[itsSize];

83: for (int i = 0; i< itsSize; i++)

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

85: }

86:

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

88: template < class T>

89: Array< T> & Array< T>:: 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< itsSize; i++)

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

98: return *this;

99: }

100:

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

102: int main()

103: {

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

105: Array< Animal> 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< int> ";

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< int>

*** 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< T> & );

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

template < class T> ostream& operator< < (ostream&, Array< T> & )

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

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

1: #include < iostream.h>

3: const int DefaultSize = 10;

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 < class T> // объявляем шаблон и параметр

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< T> & );

43:

44: private:

45: T *pType;

46: int itsSize;

47: };

48:

49: template < class T>

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

51: {

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

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

54: }

55:

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

57:

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

59: template < class T>

60: Array< T>:: Array(int size):

61: itsSize(size)

62: {

63: pType = new T[size];

64: for (int i = 0; i< size; i++)

65: pType[i] = 0;

66: }

67:

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

69: template < class T>

70: Array< T>:: Array(const Array & rhs)

71: {

72: itsSize = rhs.GetSize();

73: pType = new T[itsSize];

74: for (int i = 0; i< itsSize; i++)

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

76: }

77:

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

79: template < class T>

80: Array< T> & Array< T>:: 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< itsSize; 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< int> 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< < () определена для каждого типа объекта, сохраняемого в массиве.

⇐ Предыдущая 66 67 68 69 707172 73 74 75 Следующая ⇒