ATL / WTL / STL

'class' : multiple copy constructors specified

The class has multiple copy constructors of a single type. The first constructor is used.

class TheClass {
    int member;
public:
    void DoSomething();
};

// Header file
struct Impl; // Forward decl
class TheClass {
     std::auto_ptr<Impl> pimpl;
public:
     TheClass();
     void DoSomething();
};

// Cpp file
struct Impl {
     int member;
};
 
TheClass::TheClass() : pimpl(new Impl) { }
void TheClass::DoSomething() { manipulate(pimpl->member); }

//dumb class optimized away by the compiler in releases builds
template <class T> class _NoMT 
{
public:
static lock() {};
static unlock() {};
};

template <class T = _NoMT > class CMTServices 
{
T* p_;
public:
static lock() {p->lock} ;
static unlock() {p->unlock};
};


template <class T, Class Y= CMTServices> class Xpto 
{

 Y* lock_;
 void foo()
{
 lock_->lock();
 doSomething();
 lock_->unlock();  
}

};

//Methods of IMotoCar
STDMETHODIMP CMotoCar::get_Header(IHeader **Header)
{
   // TODO: Add your implementation code here
   *Header=m_pBoundRect;
   (*Header)->AddRef();
   return S_OK; 
}
  
STDMETHODIMP CMotoCar::put_Header(IHeader *Header)
{
   // TODO: Add your implementation code here
   m_pHeader=Header;
   m_pHeader->AddRef();
   return S_OK;
}

STDMETHODIMP CMotoCar::GetHeader(/*[out, retval]*/ IHeader** pHeader) 
{
    *pHeader = m_pHeader;
    if(*pHeader)
       (*pHeader)->AddRef();
    return S_OK;
}

Retrieving a copy of an internally stored pointer When a function retrieves a copy of a pointer that is stored internally by the object called, that object's code must call AddRef on the pointer before the function returns. Once the pointer has been retrieved, the originating object has no other way of determining how its lifetime relates to that of the internally stored copy of the pointer.

Out parameters from functions, including return values To set the out parameter, the function must have a stable copy of the interface pointer. On return, the caller is responsible for releasing the pointer. Therefore, the out parameter does not need a separate reference count.

• If you are returning a value by reference - AddRef() is required
  
• If you are returning a value by value - AddRef() should NOT be called