Синтаксис напоминает обычную перегрузку функций класса, разве что количество аргументов уменьшается на 1 по сравнению с формой внешней функции.

class String { 
private: 
 char* s ; 
public: 
 // К онструкторы и т.д. 
  String& operator+(const String&) const; 
}; 
String& String::operator+(const String& s1) const 
{ 
  char* s2 = new char[strlen(s1.s) + strlen(s) + 1]; 
 strcat(s2, s 1, s ); 
 String n ewStr(s2); 
 delete s 2; 
 return n ewStr; 
}
String s1 = “Hello”; 
String s2 = “Goodbye”; 
String s3 = s1 + s2;

Любой оператор может быть перегружен в форме функции класса. Если оператор может перегружаться как внешней функцией, так и функцией класса, какую из двух форм выбрать? Ответ: используйте перегрузку в форме функции класса, если только у вас не найдется веских причин для перегрузки внешней функцией. Из этих причин наиболее распространены следующие:

1. Первый аргумент относится к базовому типу (например, int или double).
   
2. Тип первого аргумента определен в коммерческой библиотеке, которую нежелательно модифицировать.
   

Компилятор ищет перегрузку в форме функций класса, просматривая левую часть бинарных операторов и единственный аргумент унарных. Если ваш тип указывается справа и вы хотите воспользоваться перегрузкой в форме функции класса, вам не повезло. Самый распространенный пример перегрузки в форме внешней функции — оператор << в библиотеке ostream.

ostream& operator<<(ostream& os, const String& s) 
{ 
 os < < s tr.s;  // П редполагается, что данная функция является другом 
 return o s; 
}

Перегрузка должна осуществляться в форме внешней функции, поскольку ваш тип, String, находится справа — если, конечно, вы не хотите залезть в готовые заголовки iostream.h и включить в класс ostream перегрузку в форме функции класса для своего класса String. Наверное, все-таки не хотите.

Примечание: предыдущий пример может не работать в вашем компиляторе, если функции strlen и strcat, как это часто бывает, по недосмотру разработчиков получают char* вместо const char*.

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

String& String::operator+(const String& s1) const 
{ 
  char* s2 = new char[strlen((char*)s1.s) + strlen(s) + 1]; 
 strcat(s2, ( char*)s1.s, s ); 
 String n ewStr(s2); 
 delete s 2; 
 return n ewStr; 
}

Видите, что происходит, если кто-то забывает о константности?