    21:	cout « "\nValue of a == " « a.GetValueO; 
    22:	cout « "\nValue of b == " « b.GetValueO; 
    23:	cout « "\na + b +   6 == " « (a + b + 6); 
    24:	cout « "\na - b + 10 == " « (a - b + 10) 
    25:	« '\n'; 
    26:	return 0; 
    27:	} 
    28: 
    29:	TStrOp::TStrOp(const char *s) 
    30:	{ 
    31:	  strncpy(value, s, 11); 
    32:	   value[11] = 0; 
    33:	} 
    34: 
    35:	long TStrOp::operator+(TStrOp b) 
    36:	{ 
    37:	    return (atol(value) + atol(b,value)); 
    38:	} 
    39: 
    40:	long TStrOp::operator-(TStrOp b) 
    41:	{ 
    42:	   return (atol(value) - atol(b.value)); 
    43:	} 

    Рассмотрим перегруженные операторные функции-члены, объявленные в строках 
12-13 и реализованные в строках 32-33. Поскольку эти функции — члены класса 
TStrOp, они уже имеют доступ к защищенным и закрытым членам класса, таким 
образом, не надо их указывать друзьями класса. Кроме того, эти функции-члены 
получают указатель this, ссылающийся на объект, для которого они были вызваны. 
Следовательно, функциям необходим всего лишь один параметр, а не два, как 
ранее. Для сложения двух строковых значений operator+() суммирует длинные 
целые значения, эквивалентные выражениям this->value и Ь.value. 
    Функциям-операторам и функциям-членам необходимо соответствующее число 
параметров. Вы не сможете :бъявить operator+() в строке 12 следующим образом: 

    long operator+(TStrOp a,  TStrOp b);      // ??? 

    Эта строка не скомпилируется, поскольку operator+() — член класса TStrOp и 
как функция-член получает указатель this, ссылающийся на объект класса. С 
учетом указателя this и аргументов а и b всего функция имеет три параметра, а 
перегруженному бинарному оператору, подобному operator+(), необходимы только 
два. Для сложения двух объектов класса TStrOp функция operator+() суммирует 
this.value и b.value (строка 37). Ей не нужен третий параметр. Функция-член 
operator-() также получает указатель this и, следовательно, нуждается только в 
одном аргументе для перегрузки бинарного оператора вычитания (строки 40-43). 

    Перегрузка унарных операторов 

    Унарным операторам, подобным унарному плюсу и унарному минусу, необходим 
только один аргумент. Вы можете перегрузить эти и другие унарные операторы с 
помощью трюка, аналогичного проиллюстрированному в предыдущем разделе. 
    Как и в случае с бинарными операторами, вы можете объявить функцию 
перегрузки унарного оператора другом или членом класса. В объявлении 
дружественной функции перегрузки унарного оператора необходим тольк один параметр, 
имеющий тип класса (только одно значение, над которым надо произвести действия). 
Например, добавьте следующее объявление в STROPS2.CPP (листинг 12.5) прямо над 
private: в строке 6: friend long operator-(TStrOp a); 
    Даже несмотря на то что в строке 13 перегружен оператор вычитания, 
конфликтов не возникнет, поскольку в новом объявлении задан один параметр. 
Функция-член в строке 13 получает скрытый параметр this. Hoвая функция, не 
являющаяся членом класса, не получит указателя this. Для реализации новой 
функции переписи унарного минуса, не являющейся членом класса, добавьте следующие строки 
после функции main():

    long operator-(TStrOp a) 
    {
      return -atol(a.value); 
    }

     Поскольку унарный оператор "минус" — друг класса, оператор return имеет 
непосредственный доступ к закрытому члену параметра а, имеющему тип класса 
TStrOp. Теперь функция закончена, и компилятор может вычислить выражения, 
использующие унарный минус и объекты этого типа класса. Например, добавьте 
следующий оператор в функцию main() (лучше всего после строки 20): 

    cout "\п-а   == " « -а ; 


    15. Передовые средства C++     375 
