这个 _com_ptr_t 移动任务有什么目的吗？

Question

So we have this code

_com_ptr_t& operator=(_com_ptr_t&& cp) throw()
{
    if (m_pInterface != cp.m_pInterface) {
        Interface* pOldInterface = m_pInterface;

        m_pInterface = cp.m_pInterface;
        cp.m_pInterface = nullptr;

        if (pOldInterface != nullptr) {
            pOldInterface->Release();
        }
    }
    return *this;
}

The pOldInterface is Release()d on move assignment. Why are move assignment/constructor operations not implemented as swaps which lets the Release() occur naturally on moved object's destructor just use the nullptr assignment or Release() to manually trigger it early?

I always implement move constructors as swap operations. Is this bad practice?

My code would be

_com_ptr_t& operator=(_com_ptr_t&& cp) throw()
{
    if (m_pInterface != cp.m_pInterface) {
        Interface* pOldInterface = m_pInterface;
        m_pInterface = cp.m_pInterface;
        cp.m_pInterface = pOldInterface;
        // or just std::swap(m_pInterface, cp.m_pInterface);
    }
    return *this;
}

Is there a reasoning behind MS _com_ptr_t choice? This question also applies to any move assignment/constructor so this context is more/less relevant. It's all about whether we release data or we swap it?

Answer 1

I always implement move constructors as swap operations. Is this bad practice?

Normally note a bad practice, but depends on what Release() does (in the first code). If the Release() has to take care of any related objects upon Interface movements, the implementation might be different than a simple swap operation.

For a trivial case, I personally prefer std::exchange idiom (need c++14 or later), which kind of make sense in the move-operations.

_com_ptr_t& operator=(_com_ptr_t&& cp) throw()
{
    if (m_pInterface != cp.m_pInterface)
    {
        m_pInterface = std::exchange(cp.m_pInterface, nullptr);
    }
    return *this;
}