class Obj {
public:
    Obj() { LOG(L"new Obj"); }
    ~Obj() { LOG(L"del Obj"); }
};

template<class T, template<class> class W> class Emit {
public:
    Emit(T* ref) : m_ref(ref) { LOG(L"new Emit"); }
    W<T> get() { LOG(L"get from Emit"); return W<T>(m_ref); }
    T* m_ref;
};

template<class T> class Wrap {
public:
    Wrap() : m_ref(0) { LOG(L"new Wrap(0)"); }
    Wrap(T* ref) : m_ref(ref) { LOG(L"new Wrap(T*)"); }
    Wrap(Wrap<T>& ref) : m_ref(&ref) { LOG(L"new Wrap(Wrap<T>&)"); ref.m_ref = 0; }
    ~Wrap() { LOG(L"del Wrap : %p",m_ref); }

    operator T*() const { LOG(L"Wrap to T*"); return m_ref; }

    Wrap<T>& operator=(T* ref) { LOG(L"Wrap = T*"); m_ref = ref; return *this; } // this will be used, incorrectly, when i use assignment instead
    Wrap<T>& operator=(Wrap<T>& ref) { LOG(L"Wrap = Wrap<T>&"); m_ref = ref.m_ref; ref.m_ref = 0; return *this; }

    T* m_ref;
};

void wtf() {
    Emit<Obj, Wrap> emit(new Obj());
    Wrap<Obj> wrap = emit.get();
}

new Obj
new Emit
get from Emit
new Wrap(T*)        - first formed in Emit::get
new Wrap(Wrap<T>&)  - copy constructor (return value optimization removes the second one)
del Wrap : 00000000 - delete temporary object ... content has been transferred
del Wrap : 006F6580 - "wrap" goes out of scope

new Obj
new Emit
get from Emit
new Wrap(T*)        - first formed in Emit::get
Wrap to T*          - have to downcast/unwrap to use the wrong copy constructor
new Wrap(T*)        - using the wrong copy constructor
del Wrap : 006F6580 - delete temporary object ... this is bananas
Wrap to T*               ???
new Wrap(T*)             ??? going bananas twice, presumably first at "Wrap<Obj> get() { return Wrap<Obj>(ref); }" and then "Wrap<Obj> = emit.get();"
del Wrap : 006F6580      ??? given that it goes bananas - no return value optimization is done with Debug nor Release target.
del Wrap : 006F6580 - "wrap" goes out of scope

Make Wrap(T* ref) explicit.

Otherwise the compiler will prefer it over a non-const copy constructor.

new Obj
new Emit
get from Emit
new Wrap(T*)
del Wrap : 00556580

new Obj
new Emit
new Wrap(0)
get from Emit
new Wrap(T*)
Wrap to T*      - bananas
Wrap = T*
del Wrap : 005565C0
del Wrap : 005565C0

You probably want the copy constructor and the assignment operator to take the parameter by const reference instead of by reference. For example, the return statement is Obj::get() takes an unexepected route because it cannot copy by the copy constructur; it would pass a temporary value to a function taking a non-const reference which is not legal.

The same problem applies to the assignment operator; the return value from Obj::get() is a temporary and cannot be passed to the assignment operator taking a non-const reference. But your assignment operator is behaving in an unexpected way anyway; it modifies the right-hand-side (sets ref.m_ref to zero) which is not the expected behavior of a copy-assignment. What you have implemented is the move-assignment operator disguised as the copy-assignment operator.

1) You probably want the copy constructor and the assignment operator to take the parameter by const reference instead of by reference. For example, the return statement is Emit::get() takes an unexepected route because it cannot copy by the copy constructur; it would pass a temporary value to a function taking a non-const reference which is not legal.

2) The same problem applies to the assignment operator; the return value from Obj::get() is a temporary and cannot be passed to the assignment operator taking a non-const reference.

3) But your assignment operator is behaving in an unexpected way anyway; it modifies the right-hand-side (sets ref.m_ref to zero) which is not the expected behavior of a copy-assignment. What you have implemented is the move-assignment operator disguised as the copy-assignment operator.