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

В листинге 15.1 представлен класс String, в котором перегружается operator+. В нем также объявляется конструктор, принимающий указатель на константную строку, поэтому объект класса String можно создавать из строки с концевым нулевым символом.

Примечание: Строки в С и C++ представляют собой массивы символов, заканчивающиеся концевым нулевым символом. Такая строка получается, например,в следующем выражении присвоения: myString[] = "Hello World".

Но чего невозможно сделать в классе String, так это получить новую строку в результате сложения объекта этого класса с массивом символов:

char cString[] = { "Hello"} ; String sString(" Worid");

String sStringTwo = cString + sString; //ошибка!

Строки нельзя использовать с перегруженной функции operator+. Как объяснялось на занятии 10, выражение cString + sString на самом деле вызывает функцию cString.operator+(sString). Поскольку функция operator+() не может вызываться для символьной строки, данная попытка приведет к ошибке компиляции.

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

Листинг 15.8. Функция-друг operator+

1: // Листинг 15.8. Операторы друзья

2:

3: #include

4: #include

5:

6: // Рудиментарный класс string

7: class String

8: {

9: public:

10: // constructors

11: String();

12: String(const char *const);

13: String(const String &);

14: ~String();

15:

16: // перегруженные операторы

17: char & operator[](int offset);

18: char operator[](int offset) const;

19: String operator+(const String&);

20: friend String operator+(const String&, const String&);

21: void operator+=(const String&);

22: String & operator= (const String &);

23:

24: // методы общего доступа

25: int GetLen()const { return itsLen; }

26: const char * GetString() const { return itsString; }

27:

28: private:

29: String (int); // закрытый конструктор

30: char * itsString;

31: unsigned short itsLen;

32: };

33:

34: // конструктор, заданный по умолчанию, создает строку длиной 0 байт

35: String::String()

36: {

37: itsString = new char[1];

38: itsString[0] = '\0';

39: itsLen=0;

40: // cout << "\tDefault string constructor\n";

41: // ConstructorCount++:

42: }

43:

44: // закрытый конструктор, используемый только

45: // методами класса для создания новой строки

46: // указанного размера, заполненной нулями.

47: String::String(int len)

48: {

49: itsString = new char[len+1];

50: for (int i = 0; i<=len; i++)

51: itsString[i] = '\0';

52: itsLen=len;

53: // cout << "\tString(int) constructor\n";

54: // ConstructorCount++;

55: }

56:

57: // Преобразует массив символов в строку

58: String::String(const char * const cString)

59: {

60: itsLen = strlen(cString);

61: itsString = new char[itsLen+1];

62: for (int i = 0; i

63: itsString[i] = cString[i];

64: itsString[itsLen]='\0';

65: // cout << "\tString(char*) constructor\n";

66: // ConstructorCount++;

67: }

68:

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

70: String::String (const String & rhs)

71: {

72: itsLen=rhs.GetLen();

73: itsString = new char[itsLen+1];

74: for (int i = 0; i

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

76: itsString[itsLen] = '\0';

77: // cout << "\tString(String&) constructor\n";

78: // ConstructorCount++;

79: }

80:

81: // деструктор, освобождает занятую память

82: String::~String ()

83: {

84: delete [] itsString;

85: itsLen = 0;

86: // cout << "\tString destructor\n";

87: }

88:

89: // этот оператор освобождает память, а затем

90: // копирует строку и размер

91: String& String::operator=(const String & rhs)

92: {

93: if (this == &rhs)

94: return <

95: delete [] itsString;

96: itsLen=rhs.GetLen();

97: itsString = new char[itsLen+1];

98: for (int i = 0; i

99: itsString[i] = rhs[i];

100: itsString[itsLen] = 1\0';

101: return *this;

102: // cout << "\tString operator=\n";

103: }

104:

105: // неконстантный оператор индексирования,

106: // возвращает ссылку на символ, который можно

107: // изменить!

108: char & String::operator[](int offset)

109: {

110: if (offset > itsLen)

111: return itsString[itsLen-1];

112: else

113: return itsString[offset];

114: }

115:

116: // константный оператор индексирования,

117: // используется для константных объектов (см. конструктор-копировщик!)

118: char String::operator[](int offset) const

119: {

120: if (offset > itsLen)

121: return itsString[itsLen-1];

122: else

123: return itsString[offset];

124: }

125: // создает новый объект String, добавляя

126: // текущий обьект к rhs

127: String String::operator+(const String& rhs)

128: {

129: int totalLen = itsLen + rhs.GetLen();

130: String temp(totalLen);

131: int i, j;

132: for (i = 0; i

133: temp[i] = itsString[i];

134: for (j = 0, i = itsLen; j

135: temp[i] = rhs[j];

136: temp[totalLen]='\0';

137: return temp;

138: }

139:

140: // создает новый объект String

141: // из двух объектов класса String

142: String operator+(const String& lhs, const String& rhs)

143: {

144: int totalLen = lhs.GetLen() + rhs.GetLen();

145: String temp(totalLen);

146: int i, j;

147: for (i = 0; i

148: temp[i] = lhs[i];

149: for (j = 0, i = lhs.GetLen();; j

150: temp[i] = rhs[j];

151: temp[totalLen]='\0';

152: return temp;

153: }

154:

155: int main()

156: {

157: String s1("String 0ne ");

158: String s2("String Two ");

159: char *c1 = { "C-String 0ne " } ;

160: String s3;

161: Stnng s4;

162: String s5;

163:

164: cout << "s1: " << s1.GetString() << endl;

165: cout << "s2: " << s2.GetString() << endl;

166: cout << "c1: " << c1 << endl;

167: s3 = s1 + s2;

168: cout << "s3: " << s3.GetString() << endl;

169: s4 = s1 + cl;

170: cout << "s4: " << s4.GetStnng() << endl;

171: s5 = c1 + s2;

172: cout << "s5: " << s5.GetString() << endl;

173: return 0;

174: }

Результат:

s1: String 0ne

s2: String Two

c1: C-String One

s3: String One String Two

s4: String One C-String One

s5: C-String One String Two

Анализ:Объявления всех методов класса String, за исключением operator+, остались такими же, как в листинге 15.1. В строке 20 листинга 15.8 перегружается новый operator+, который принимает две ссылки на константные строки и возвращает строку, полученную в результате конкатенации исходных строк. Эта функция объявлена как друг класса String.

Обратите внимание, что функция operator+ не является функцией-членом этого или любого другого класса. Она объявляется среди функций-членов класса string как друг, но не как член класса. Тем не менее это все же полноценное объявление функции, и нет необходимости еще раз объявлять в программе прототип этой функции.

Выполнение функции operator+ определяется в строках 142—153. Определение выполнения функции аналогично приведенному в версии программы, представленной в листинге 15.1, за тем исключением что функция принимает в качестве аргументов две строки, обращаясь к ними с помощью открытых методов доступа класса.

Перегруженный оператор применяется в строке 171, где выполняется конкатенация двух строк.

Функции-друзья

Для объявления функции как друга класса используется ключевое слово friend, за которым следует объявление функции Это не предоставляет функции доступ к указателю this, но обеспечивает доступ ко всем закрытым и защищенным данным и функциям-членам.

Пример:

class PartNode

{ // ...

// сделаем функцию-член другого класса другом этого класса

friend void PartsList::Insert(Part*)

// сделаем другом глобальную функцию

friend int SomeFunction();

// ...

};

Настало время снабдить наш класс String возможностью использовать объект cout для вывода своих данных так же, как при выводе данных базовых типов. До сих пор для вывода значения переменной-члена приходилось использовать следующее выражение: