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>

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

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

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

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>>// Операции с указателем
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>>

К>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> fill_data(*p2);
RL> accept_data(*p2);
RL>

RL> return *p;
RL>