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 A
A>>    {
A>>        public:
A>>            operator int()
A>>//------------------ >> А где здесь оператор? operator - ключевое слово
A>>                {                                                     int - встроенный в комплятор тип данных
A>>                    return 15;                  Выходит что () есть обозначение оператора приведения типа? 
A>>                }
A>>    };
A>>//
A>>A a;
A>>int x = a; // x будет иметь значение 15.
RL>

class C
{
public:
  result_type operator ??? (arguments) .....
};
result_type operator !!! (arguments) .....

class C
{
public:
    // функциональная форма
  static C add(const C& lhs, const C& rhs);
  static C subtract(const C& lhs, const C& rhs);

  C operator + (const C& rhs) const { return add( *this, rhs ); }
};
C operator - (const C& lhs, const C& rhs) { return C::subtract(lhs, rhs); }

class C
{
public:
  static C minus(const C& arg);
    static C invert(const C& arg);
    
    C operator - () const { return negate(*this); }
};
operator !(const C& arg) { return C::minus(arg); }

class C
{
public:
    C& operator ++ (); // обычно результат пред-инкремента - это сам объект (модифицированный)
    C operator ++ (int) // а результат пост-инкремента - копия объекта до модификации
    {
        // типичная реализация пост-инкремента выглядит так (если, конечно, оператор не несёт иной смысловой нагрузки)
        C temp = *this;
        ++(*this);
        return temp;
    }
};
// внешние операторы - аналогичны
C& operator --(C& arg);
C operator --(C& arg, int) { C temp = arg; --arg; return temp; }

class C
{
public:
  operator const char* () const;
    // обрати внимание: тип возвращаемого значения совпадает с именем оператора, т.е. здесь const char*
};

class A;
class B;

class C
{
public:
    void operator = (const A& rhs);
    void operator = (const C& rhs);
    ...
};
class D
{
public:
    operator A () const;
    operator B () const;
    ...
};

main()
{
    C c;
    D d;
    c = d;
}

C y = operator-(x); // C y = -x;
C y = operator+(a,b); // C y = a+b;

>> 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; // оператор присваивания

> Кстати я так и не понял почему Этому есть какое-нибудь объяснение или просто так решили?

struct V
{
   V(int) { }
   virtual ~V() { }
};

struct D : virtual V
{
   D(int i) : V(i) { }
};

struct M : D
{
   M(int i) : V(i), D(i) { }
};

int main()
{
   M m(10);
}

; 19   :   M m(10);

    push    1
    push    10                    ; 0000000aH
    lea    ecx, DWORD PTR _m$[ebp]
    call    ??0M@@QAE@H@Z                ; M::M

simple-declaration:
   decl-specifier-seq opt init-declarator-list opt ;

init-declarator:
   declarator initializer opt

initializer:
   = initializer-clause
   ( expression-list )

тип имя = что-то;

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

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

Шаблон IPtr из PTR.H
//
// IPtr – Smart-указатель на интерфейс
// Использование: IPtr<IX, &IID_IX> spIX;
// Не используйте с IUnknown; IPtr<IUnknown, &IID_IUnknown>
// не будет компилироваться. Вместо этого используйте IUnknownPtr.
//
template <class T, const IID* piid> class IPtr
{
public:
// Конструкторы
IPtr()
{
m_pI = NULL;
}
IPtr(T* lp)
{
m_pI = lp;
if (m_pI != NULL)
{
m_pI->AddRef();
}
}
IPtr(IUnknown* pI)
{
m_pI = NULL;
if (pI != NULL)
{
pI->QueryInterface(*piid, (void **)&m_pI);
}
}
// Деструктор
~IPtr()
{
Release();
}
// Сброс в NULL
void Release()
140
{
if (m_pI != NULL)
{
T* pOld = m_pI;
m_pI = NULL;
pOld->Release();
}
}
// Преобразование
operator T*() { return m_pI; }
// Операции с указателем
T& operator*() { assert(m_pI != NULL); return *m_pI; }
T** operator&() { assert(m_pI == NULL); return &m_pI; }
T* operator->() { assert(m_pI != NULL); return m_pI; }
// Присваивание того же интерфейса
T* operator=(T* pI)
{
if (m_pI != pI)
{
IUnknown* pOld = m_pI; // Сохранить старое значение
m_pI = pI; // Присвоить новое значение
if (m_pI != NULL)
{

m_pI->AddRef();
}
if (pOld != NULL)
{
pOld->Release(); // Освободить старый интерфейс
}
}
return m_pI;
}
// Присваивание другого интерфейса
T* operator=(IUnknown* pI)
{
IUnknown* pOld = m_pI; // Сохранить текущее значение
m_pI == NULL ;
// Запросить соответствующий интерфейс
if (pI != NULL)
{
HRESULT hr = pI->QueryInterface(*piid, (void**)&m_pI);
assert(SUCCEEDED(hr) && (m_pI != NULL));
}
if (pOld != NULL)
{
pOld->Release(); // Освободить старый указатель
}
return m_pI;
}
// Логические функции
BOOL operator!() { return (m_pI == NULL) ? TRUE : FALSE; }
// Требует компилятора, поддерживающего BOOL
operator BOOL() const
{
return (m_pI != NULL) ? TRUE : FALSE;
}
// GUID
const IID& iid() { return *piid; }
private:
// Хранимый указатель
141
T* m_pI;
};

RL>// Преобразование
RL>operator T*() { return m_pI; }

CSomePtr ptr;
void foo(ISome* p);

ISome* p = ptr;
foo(ptr);

RL>// Операции с указателем
RL>T& operator*() { assert(m_pI != NULL); return *m_pI; }

// эквивалентные способы вызвать метод: оператор-> и разыменовать...
((ISome*)ptr)->method();
(*((ISome*)ptr)).method();
(*ptr).method();

RL>T** operator&() { assert(m_pI == NULL); return &m_pI; }-------- > только этот понятен

// Кстати, довольно зловредный оператор. В ряде случаев мешает.
// Лучше уж ввести в CSomePtr метод reference(), возвращающий ссылку на переменную-член

RL>T* operator->() { assert(m_pI != NULL); return m_pI; }

// оператор доступа
((ISome*)ptr)->method();
ptr->method();

result_of_arrow_1 t1 = obj.operator->();
// если result_of_arrow_1 - не указатель, то
result_of_arrow_2 t2 = t1.operator->();
// если опять не указатель, то
result_of_arrow_3 t3 = t2.operator->();
...
// наконец, tN - это указатель
(*tN).member

class C
{
public:
    // функциональная форма
  static C add(const C& lhs, const C& rhs);  

  C operator + (const C& rhs) const { return add( *this, rhs ); }
};

RL>Посмотрим, как выглядят операторы-члены.
RL>1) инфиксные двухместные (например, x+y). При этом левый аргумент (подразумеваемый) - это сам объект, а правый указывается в сигнатуре. Сравни:
RL>class C
RL>{
RL>public:
RL>    // функциональная форма
RL>  static C add(const C& lhs, const C& rhs);  

RL>  C operator + (const C& rhs) const { return add( *this, rhs ); }
RL>};
RL>

С a, b;
a + b; // эквивалентно a.operator+(b);

RL>>// Преобразование
RL>>operator T*() { return m_pI; }

К>CSomePtr ptr;
К>void foo(ISome* p);

К>ISome* p = ptr;
К>foo(ptr);

RL>>// Операции с указателем
RL>>T& operator*() { assert(m_pI != NULL); return *m_pI; }

К>// эквивалентные способы вызвать метод: оператор-> и разыменовать...
К>((ISome*)ptr)->method();
К>(*((ISome*)ptr)).method();
К>(*ptr).method();

RL>>T** operator&() { assert(m_pI == NULL); return &m_pI; }-------- > только этот понятен

К>// Кстати, довольно зловредный оператор. В ряде случаев мешает.
К>// Лучше уж ввести в CSomePtr метод reference(), возвращающий ссылку на переменную-член

RL>>T* operator->() { assert(m_pI != NULL); return m_pI; }

К>// оператор доступа
К>((ISome*)ptr)->method();
ptr->>method();
К>

К>result_of_arrow_1 t1 = obj.operator->();
К>// если result_of_arrow_1 - не указатель, то
К>result_of_arrow_2 t2 = t1.operator->();
К>// если опять не указатель, то
К>result_of_arrow_3 t3 = t2.operator->();
К>...
К>// наконец, tN - это указатель
К>(*tN).member
К>

С operator + (const C lPar, const C rPar);

 class С
{
  C add(val1, val2);
  C operator + (C rPar) const {return add(*this, rPar);}
};

 class cPtr
{
   private:
   T* p;//указатель на искомый интерфейс
   public:
   operator T*() {  return m_pI; }
   T& operator*() { return *m_pI; }
   T** operator&() { return &m_pI; }
   T* operator->() { return m_pI; }
};

RL>// Операции с указателем
RL>>>T& operator*() { assert(m_pI != NULL); return *m_pI; }

struct Data
{
  int x;
  void foo();
};

// некоторые функции...
void accept_data(Data d); // входной параметр
void fill_data(Data& d); // выходной параметр


struct SmartPtr
{
  Data* p;

  Data& operator* () { return *p; }
};

main()
{
  Data* p1;
  SmartPtr p2;
  . . . . .

  // обычный указатель      // явный доступ к члену умного     // то же самое,
                            // -- обычному указателю           // но завёрнутое в оператор разыменования
  fill_data(*p1);           fill_data(*(p2.p));                fill_data(*p2);
  accept_data(*p1);         accept_data(*(p2.p));              accept_data(*p2);
}

RL>С operator + (const C lPar, const C rPar);
RL>

RL>C x,y,z;

RL>z = +(x,y);

RL>С x,y,z;

RL>z = x+y;

 z = x+y;

 z = operator+ (x,y);

 z = x.operator+ (y);

RL> class С
RL>{
RL>  C add(val1, val2);
RL>  C operator + (C rPar) const {return add(*this, rPar);}
RL>};
RL>

RL>С obj;
RL>C anyPar;
RL>C res;
RL>res = obj.operator + (anyPar);

RL>С obj;
RL>C anyPar;
RL>C res;

RL>res = +anyPar;

RL> class cPtr
RL>{
RL>   private:
RL>   T* p;//указатель на искомый интерфейс
RL>   public:
RL>   operator T*() {  return m_pI; }
RL>   T& operator*() { return *m_pI; }
RL>   T** operator&() { return &m_pI; }
RL>   T* operator->() { return m_pI; }
RL>};

RL>

RL>Прошу извинить если надоедаю

void foo(T* pointer);
void bar(T value);
void xyz(T& reference);
void get(T** address_of_pointer);

main()
{
  cPtr ptr;

  get(&ptr);              get(&(ptr.m_pI));
  foo(ptr);               foo(ptr.m_pI);
  bar(*ptr);              bar(*(ptr.m_pI));
  xyz(*ptr);              xyz(*(ptr.m_pI));
  ptr->call();            ptr.m_pI->call();
}

RL>>// Операции с указателем
RL>>>>T& operator*() { assert(m_pI != NULL); return *m_pI; }
К>

К>struct Data
К>{
К>  int x;
К>  void foo();
К>};

К>// некоторые функции...
К>void accept_data(Data d); // входной параметр
К>void fill_data(Data& d); // выходной параметр


К>struct SmartPtr
К>{
К>  Data* p;

К>  Data& operator* () { return *p; }
К>};

К>main()
К>{
К>  Data* p1;
К>  SmartPtr p2;
К>  . . . . .

К>  // обычный указатель      // явный доступ к члену умного     // то же самое,
К>                            // -- обычному указателю           // но завёрнутое в оператор разыменования
К>  fill_data(*p1);           fill_data(*(p2.p));                fill_data(*p2);
К>  accept_data(*p1);         accept_data(*(p2.p));              accept_data(*p2);
К>}
К>

RL>>С operator + (const C lPar, const C rPar);
RL>>

RL>>C x,y,z;

RL>>z = +(x,y);
К>

RL>>С x,y,z;

RL>>z = x+y;
К>

 z = x+y;

 z = operator+ (x,y);

 z = x.operator+ (y);

RL>> class С
RL>>{
RL>>  C add(val1, val2);
RL>>  C operator + (C rPar) const {return add(*this, rPar);}
RL>>};
RL>>

К>

RL>>С obj;
RL>>C anyPar;
RL>>C res;
RL>>res = obj.operator + (anyPar);
К>

//равносильно obj+anyPar? Т.е текущий объект складывается с параметром, и что будет блин не догоняю ((

RL>>С obj;
RL>>C anyPar;
RL>>C res;

RL>>res = +anyPar;
К>

RL>> class cPtr
RL>>{
RL>>   private:
RL>>   T* p;//указатель на искомый интерфейс
RL>>   public:
RL>>   operator T*() {  return m_pI; }
RL>>   T& operator*() { return *m_pI; }
RL>>   T** operator&() { return &m_pI; }
RL>>   T* operator->() { return m_pI; }
RL>>};

RL>>

RL>>Прошу извинить если надоедаю

К>void foo(T* pointer);
К>void bar(T value);
К>void xyz(T& reference);
К>void get(T** address_of_pointer);

К>main()
К>{
К>  cPtr ptr;

К>  get(&ptr);              get(&(ptr.m_pI));
К>  foo(ptr);               foo(ptr.m_pI);
К>  bar(*ptr);              bar(*(ptr.m_pI));
К>  xyz(*ptr);              xyz(*(ptr.m_pI));
  ptr->>call();            ptr.m_pI->call();
К>}
К>

// обычный указатель      // явный доступ к члену умного     // то же самое,
К>                            // -- обычному указателю           // но завёрнутое в оператор разыменования
К>  fill_data(*p1);           fill_data(*(p2.p));                fill_data(*p2);
К>  accept_data(*p1);         accept_data(*(p2.p));              accept_data(*p2);

 fill_data(*p2);
 accept_data(*p2);

 return *p;