unique_interface_ptr

A unique_interface_ptr is a smart pointer which represents exclusive ownership of an object that implements interface IObject and will call the Destroy method when it destructs.

Consider the following $interface definitions and a class that implements them:

$interface+ Ix : ceda::IObject
{
    int get() const;
};

$interface+ Iy : Ix
{
    void set(int x);
};

$class X isa Iy
{
public:
    X(int x) : x(x) {}
    int get() const { return x; }
    void set(int v) { x = v; }
private:    
    int x;
};

X implements interface IObject so therefore a Destroy method is generated by the compiler which calls delete this.

void X::Destroy() const
{
    delete this;
}

In the following example the variable p which is a unique_interface_ptr takes ownership of the dynamically allocated instance of class X ensuring it is deleted:

void main()
{
    ceda::unique_interface_ptr<Iy> p(new X(10));
    assert( p->get() == 10 );
}

If D is a sub-interface of B, then unique_interface_ptr<D> is implicitly convertible to unique_interface_ptr<B>.

In many ways a unique_interface_ptr is analogous to a std:::unique_ptr :

• The smart pointer owns and manages another object through a pointer and disposes of that object when the smart pointer goes out of scope
• The smart pointer may alternatively own no object, in which case it is called empty
• The default constructor or the constructor which is given a nullptr initialises the smart pointer to empty
• The unique_interface_ptr class explicitly deletes its lvalue copy constructor and lvalue assignment operator.
• The smart pointer can be assigned a new value using operator= or reset and that causes the previous object managed by the smart pointer to be disposed. Furthermore, a call to reset() or reset(nullptr) or operator= with nullptr clears the smart pointer (i.e. makes it empty)
• There is an (explicit) conversion to bool which is true if and only if the smart pointer is non-empty
• The method release releases ownership of the managed object. A pointer to the object is returned and the caller must take on responsibility for disposing of the object. The smart pointer becomes empty after calling release.
• The method get returns a pointer to the managed object.
• operator* and operator-> allow the smart pointer to be used like a raw pointer.
• The comparison operators operator==, operator!=, operator<<, operator<=, operator>, operator>= allow for comparing to another unique_interface_ptr or with nullptr.