ATL / WTL / STL

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

STDMETHODIMP CClient::get_Devices(IDevices **pVal)
{
  //return a pointer to the devices collection...
  HRESULT hr = m_Devices->QueryInterface(__uuidof(IDevices), (void**)pVal);
  if (FAILED(hr))
  {
    return E_FAIL;
  }
  return S_OK;
}

typedef struct __Item
{
   int m_iXX1;
   int m_iXX2;
   list<__Item> m_Right; // <- This one
}_Item;

struct list { 
   int value;
   list next; // Ouchie!
};