>>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;
}

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

init-declarator:
   declarator initializer opt

initializer:
   = initializer-clause
   ( expression-list )

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

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

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

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

Шаблон 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;
};