What are the duck-typing requirements of wil com_ptr?

Raymond Chen

We continue our survey of duck-typing requirements of various C++ COM smart pointer libraries by looking at wil’s com_ptr, running it through our standard tests.

// Dummy implementations of AddRef and Release for
// testing purposes only. In real code, they would
// manage the object reference count.
struct Test
    void AddRef() {}
    void Release() {}
    Test* AddressOf() { return this; }

struct Other
    void AddRef() {}
    void Release() {}

// Pull in the smart pointer library
// (this changes based on library)
#include <wil/com.h>
using TestPtr = wil::com_ptr<Test>;  
using OtherPtr = wil::com_ptr<Other>;

void test()
    Test test;

    // Default construction
    TestPtr ptr;

    // Construction from raw pointer
    TestPtr ptr2(&test);

    // Copy construction
    TestPtr ptr3(ptr2);

    // Attaching and detaching
    auto p = ptr3.detach();

    // Assignment from same-type raw pointer
    ptr3 = &test;

    // Assignment from same-type smart pointer
    ptr3 = ptr;

    // Accessing the wrapped object
    // (this changes based on library)
    if (ptr.get() != &test) {
        std::terminate(); // oops
    if (ptr->AddressOf() != &test) {
        std::terminate(); // oops

    // Returning to empty state
    ptr3 = nullptr;

    // Receiving a new pointer
    // (this changes based on library)
    Test** out = &ptr3;
    out = ptr3.put();
    out = ptr3.addressof();

    // Bonus: Comparison.
    if (ptr == ptr2) {}
    if (ptr != ptr2) {}
    if (ptr < ptr2) {}

    // Litmus test: Accidentally bypassing the wrapper

    // Litmus test: Construction from other-type raw pointer
    Other other;
    TestPtr ptr4(&other);

    // Litmus test: Construction from other-type smart pointer
    OtherPtr optr;
    TestPtr ptr5(optr);

    // Litmus test: Assignment from other-type raw pointer
    ptr = &other;

    // Litmus test: Assignment from other-type smart pointer
    ptr = optr;

    // Destruction

Once again, we encounter the same glitch as we did with ATL CComPtr and WRL ComPtr:

com.h(363,1): error C2440: '=': cannot convert from 'void' to 'ULONG'

It’s coming from this code:

    void attach(pointer other) WI_NOEXCEPT
        auto ptr = m_ptr;
        m_ptr = other;
        if (ptr)
            ULONG ref;
            ref = ptr->Release();
            WI_ASSERT_MSG(((other != ptr) || (ref > 0)), "Bug: Attaching the same already assigned, destructed pointer");

The code peeks at the reference count of the outgoing object and confirms that we didn’t attach a smart pointer to itself.

As usual, the fix is to make the Release method return a ULONG representing the new reference count.

struct Test
    void AddRef() { }
    // Dummy implementation for testing purposes only.
    ULONG Release() { return 1; }

We have to make a small tweak to the boilerplate by switching to lowercase names for detach and attach, because that’s how wil spells them.

Once we fix that up, the basic tests all pass. The comparison tests compare the wrapped pointers.

There are three ways to receive a pointer in wil. You can use the & operator, which is a shorthand for the method call put(), which releases the old pointer and nulls it out, then returns the address of the pointer so a new value can be placed there. Alternatively, you can use addressof(), which does not release the old pointer. Use addressof() in the cases where the parameter is used as an in/out pointer.

wil does not use the ATL trick of “coloring” the return value of the -> operator, so you don’t have all the hassles of matching the signatures, but you also don’t get protection from accidentally doing a ptr->Release() when you meant to do a ptr.reset(). Fortunately, there is no ptr.release() method, so the mistake is a little less likely.

The other-type litmus tests all pass. They all result in various types of compile-time errors.

Okay, so here’s the scorecard for wil::com_ptr.

wil::com_ptr scorecard
Default construction Pass
Construct from raw pointer Pass
Copy construction Pass
Destruction Pass
Attach and detach Pass
Assign to same-type raw pointer Pass
Assign to same-type smart pointer Pass
Fetch the wrapped pointer get()
Access the wrapped object ->
Receive pointer via & release old
Release and receive pointer put()
Preserve and receive pointer addressof()
Return to empty state Pass
Comparison Pass
Accidental bypass Fail
Construct from other-type raw pointer Pass
Construct from other-type smart pointer Pass
Assign from other-type raw pointer Pass
Assign from other-type smart pointer Pass
T must have a method of the form ULONG Release().
The T::Release method must return nonzero if the object is still alive.

Next time, we’ll finish our tour of COM smart pointer classes by looking at C++/WinRT’s com_ptr.


Discussion is closed.

Feedback usabilla icon