#include <iostream>
using namespace std;

template <class T>
class _pointer
{
public:
    _pointer() : m_t(0) {}
    _pointer(T* t) : m_t(t) {}
    ~_pointer() { if (m_t) delete m_t; }

    operator T* () { return m_t; }

private:
    explicit _pointer(const _pointer&) {}
    const _pointer& operator =(const _pointer&) { return *this; }

private:
    T* m_t;
};

class SomeClass
{
public:
    SomeClass() { cout << "ctor" << endl; }
    ~SomeClass() { cout << "dtor" << endl; } 
};

typedef _pointer<SomeClass> SomeClassPtr;

SomeClass* MakeSomeClass()
{ return new SomeClass; }

int main(int argc, char* argv[])
{
    SomeClassPtr pPtr = MakeSomeClass();
    cout << "test" << endl;
    return 0;
}

ctor
test
dtor

ctor
dtor
test
dtor

RB>int main(int argc, char* argv[])
RB>{
RB>    SomeClassPtr pPtr = MakeSomeClass();
RB>    cout << "test" << endl;
RB>    return 0;
RB>}

_pointer<SomeClass> pPtr = new SomeClass;

_pointer<SomeClass> pPtr(new SomeClass);

_pointer<SomeClass> p = new SomeClass;

_pointer<SomeClass> p = _pointer<SomeClass>(new SomeClass);

_pointer<SomeClass> p(new SomeClass);

RB>_pointer<SomeClass> p = new SomeClass;
RB>

RB>_pointer<SomeClass> p = _pointer<SomeClass>(new SomeClass);
RB>

RB>_pointer<SomeClass> p(new SomeClass);
RB>

class A
{
public:
 A() {}
 A(int) {}
};

A a = A();
A a;

A a = A(1);
A a(1);

A a[3]={A(),A(1),A(2)};
// как-будто :
// a[0] = A() ==> a[0])()
// a[1] = A(1) ==> a[1](1)
// a[2] = A(2) ==> a[2](2)

object foo()
{
  ...
  return object(x,y,z); // здесь можно напрямую сконструировать результат
  ...
  object v;
  ...
  return v; // здесь придётся копировать
  ...
  return p() ? v : object(x,y,z); // а здесь однозначно придётся копировать - или из v, или из временного объекта
  ...
}

// аналогично - при инициализации

object a(x,y,z); // конструктор в явном виде

object b = object(x,y,z);
object c = b;
object d = p() ? a : object(x,y,z);

...
__>

A a = 1;
// Как воспримет компилятор?
// Так
A a = A(1);
// или так
A a(1);

_pointer(T* t) : m_t(t) {}

_pointer(pointer& rhs): m_t(rhs.m_t)
{
    rhs.m_t = 0;//чтобы избежать двойного удаления
}

DEA>>_pointer(pointer const& rhs): m_t(rhs.m_t)
DEA>>{
DEA>>    const_cast<pointer&>(rhs).m_t = 0;//чтобы избежать двойного удаления
DEA>>}

K>_pointer(pointer& rhs): m_t(rhs.m_t)
K>{
K>    rhs.m_t = 0;//чтобы избежать двойного удаления
K>}
K>