1. Имя. Имена операторов стандартизированны. Ты можешь как угодно использовать те, что есть, но не можешь создавать свои
   
2. Количество параметров. Ты мошешь как угодно обрабатывать параметры, но не можешь изменить их число. Не может быть операции + на тремя аргументами.
   
3. Синтаксис вызова. Если для обычной функции параметры перечисляются в скобках, через запятую, после имени функции, то для операторов это не так.

int a = 3;
int b = 5;
int c = a + b;

complex a;
complex b;
complex c = a + b;

complex a;
complex b;
complex c = ComplexAdd(a, b);

class string
 {
  private:
   char * str;
   int len;
  public:
   string(char * init)
    {
     len = strlen(init);
     str = new char[len + 1];
     strcpy(str, init);
    }
   ~string()
    {
     delete[] str;
    }
 }

{
string a("aaaa");
string b("bbb");

b = a;
}

class string
 {
  private:
   char * str;
   int len;
  public:
   string(char * init)
    {
     len = strlen(init);
     str = new char[len + 1];
     strcpy(str, init);
    }
   ~string()
    {
     delete[] str;
    }

// Возвращаем ссылку на string.
// Если не знаешь, что такео сылки, не надо утруждать себя мыслями зачем,
// достаточно пока знать, что это позволяет избежать лишнего копирования
   string & operator = (const string & s) 
    {
// Удаляем старую строку, она нам больше не понадобится.
// Обрати внимание, что это очень похоже на код деструктора
     delete[] str; 
// Выясняем длину строки и выделяем необходимое количество байт. Далее копируем новую строку в выделенную память.
// Обрати внимание, что это очень похоже на код конструктора
     len = s.len;
     str = new char[len + 1];
     strcpy(str, s.str);
// Возвращаем то, гед сейчас новое значение строки, то есть сам объект.
     return *this;
    }
 }

string a("kuku")
string b = a; // скорее всего соптимизируется в string b(a);

   string(const string & s) 
    {
     len = s.len;
     str = new char[len + 1];
     strcpy(str, s.str);
    }

class string2: public string
 {
 }

class string2
 {
  public:
   operator string(); // оператор преобразования типа
 }

class TTest
{
public:
  TTest(int){cout << "Constructor";}
  int operator=(int){cout << "Operator";return 1;}
};

int main( int argc, char * argv[] )
{
  TTest test = 7;
  return 0;
}

class TTest
{
public:
//  TTest(int){cout << "Constructor";}
  int operator=(int){cout << "Operator";return 1;}
};

int main( int argc, char * argv[] )
{
  TTest test = 7;
  return 0;
}

class string2
 {
  public:
   operator string(); // оператор преобразования типа---------------->> Поясните пожалуйста как он работает.
 }

clas error
{
   int errorCode;
 public:
   error(int value) {errorCode = value;}
   
   void ShowError()
   {
     if (errorCode == 1) MessageBox(...)....
     if (errorCode == 2) MessageBox(...)....
   }
};

class A
{
  public:
  (A) operator = (int RetCode)
  {
    if !RetCode return 0;
    throw error(RetCode);------------------------------------>> Вот это и есть тот "паразитный" код который я пытаюсь убрать из основного текста
                                                                программы и скрыть его внутри оператора =
  } 
};

A a;   
.....
.....
Гдето в коде...
a = CreateSemaphore(...); ---------------->> вот здесь по замыслу, должен вызываться перегруженый оператор и создавать объект исключения,
                                             который потом будет пойман в catch error& {} 

catch(error& e)
{
  e.ShowError();
}

RL>class string2
RL> {
RL>  public:
RL>   operator string(); // оператор преобразования типа---------------->> Поясните пожалуйста как он работает.
RL> }
RL>

class A
    {
        public:
            operator int()
                {
                    return 15;
                }
    };
//
A a;
int x = a; // x будет иметь значение 15.

//
#include <iostream>
//
using namespace std;
//
class MyException
 {
        private:
            int value;
        public:
            MyException(const int & initValue) : value(initValue)
             {
             }
            int GetValue()
                {
                    return value;
                }
 };
//
class A
    {
        public:
            A & operator = (const int & returnValue)
                {
                    if (returnValue == 0) return *this;
                    throw MyException(returnValue);
                }
    };
//
class B
    {
        public:
            B(const int & returnValue)
                {
                    if (returnValue != 0)
                        {
                            throw MyException(returnValue);
                        }
                }
    };
//
#define C(returnValue) if (returnValue != 0) throw MyException(returnValue);
//
int main( int argc, char * argv[], char * envp[] )
    {
        A a;
        try
         {
                cout << "1" << endl;
                a = 1;
         }
        catch(MyException & e)
            {
                cout << e.GetValue() << " catched" << endl;
            }
        try
         {
                cout << "2" << endl;
                B(2);
         }
        catch(MyException & e)
            {
                cout << e.GetValue() << " catched" << endl;
            }
        try
         {
                cout << "3" << endl;
                C(3);
         }
        catch(MyException & e)
            {
                cout << e.GetValue() << " catched" << endl;
            }
        return 0;
    }
//
// End of file
//

>> int a = 3;
>> int b = 5;
>> int c = a + b;
>>

int c;
c = a + b;

>> string a("kuku")
>> string b = a; // скорее всего соптимизируется в string b(a);
>>

string b; // конструктор без параметров
b = a; // оператор присваивания

  >class A
A>    {
A>        public:
A>            operator int()------------------ >> А где здесь оператор? operator - ключевое слово
A>                {                                                     int - встроенный в комплятор тип данных
A>                    return 15;                  Выходит что () есть обозначение оператора приведения типа? 
A>                }
A>    };
A>//
A>A a;
A>int x = a; // x будет иметь значение 15.
Почему x x будет иметь значение 15? Здесь же участвует operator =, как это работает?

> Для классов да, но разве для POD типов это не присваивание? Я долго читал раздел 8.5 стандарта (ИМХО на редкость непонятный) и понял именно так.

Otherwise, the initial value of the object being initialized is the (possibly converted) value of the initializer expression. Standard conversions (clause 4) will be used, if necessary, to convert the initializer expression to the cv-unqualified version of the destination type; no user-defined conversions are considered. If the conversion cannot be done, the initialization is ill-formed. [Note: an expression of type “cv1 T” can initialize an object of type “cv2 T” independently of the cv-qualifiers cv1 and cv2.

int a;
const int b = a;
int c = b;

—end note]