c++/cli wrapper for variable of native smart-pointer class

Question

I'm new to C# and C++/CLI and not quite familiar with them. I searched but couldn't find an existing solution for a pretty simple thing (which I suppose should be common).

I am writing a simple C++/CLI project (a wrapper to C++ native dlls to be used in C#). There are many examples how to write a wrapper for native class:

class CNativeClass { 
    CNativeClass() {}
    void Foo() {}
}

public ref class CNativeClassWrapper {
public:
    CNativeClassWrapper() {
        _Wrapper = new CNativeClass;
    }
    ~CNativeClassWrapper() {
        this->!CNativeClassWrapper();
    }
    !CNativeClassWrapper() {
        delete _Wrapper;
        _Wrapper = nullptr;            
    }
    void Foo() {
        _Wrapper->Foo();
    }
private:
    CNativeClass* _Wrapper;
}

This is simlified example code. There may be more native classes, there may be late initialization... A lot minor but necessary code.

Is there any wrapper for variable of native class which hides all these details? Like smart pointer templates in pure C++.

Moreover, if a native class is actually a smart pointer (90% of my cases, we use boost::shared_ptr<>) the code becomes a mess:

check can be if ( _Wrapper ) or if ( *_Wrapper ) or even if ( _Wrapper && *_Wrapper ),
access to methods (*_Wrapper)->Foo();,
how to reset? both (*_Wrapper).reset(); and _Wrapper->reset(); are correct but it is too confusing.

Does anybody know a solution for this?

Smart pointers are about as useful as a chocolate teapot in interop. The wrapper code is very boilerplate, you can auto-generate it with a tool like swig. — Hans Passant

Roman Khvostikov Roman Khvostikov · Accepted Answer · 2015-12-14T12:40:21

Well, I have finally come to such wrapper classes:

for holding general native classes:

template <class T>
public ref class native_auto_ptr
{
public:
    native_auto_ptr()
    {
        _pNative = new T;
    }
    native_auto_ptr(const native_auto_ptr<T>% rhs)
    {
        _pNative = new T( *rhs._pNative );
    }
    ~native_auto_ptr()
    {
        reset();
    }
    void reset()
    {
        delete _pNative;
        _pNative = nullptr;
    }
    T* ptr()
    {
        return _pNative;
    }
    T* operator->()
    {
        return _pNative;
    }
    operator bool()
    {
        return _pNative;
    }
    void operator=(const native_auto_ptr<T>% rhs)
    {
        *_pNative = *rhs._pNative;
    }
    void operator=(const T% rhs)
    {
        *_pNative = rhs;
    }
protected:
    !native_auto_ptr()
    {
        reset();
    }
private:
    T* _pNative;
};

for holding shared_ptr<>:

template <class T>
public ref class native_shared_ptr
{
public:
    native_shared_ptr()
    {
        _spNative = new boost::shared_ptr<T>;
    }
    native_shared_ptr(const native_shared_ptr<T>% rhs)
    {
        _spNative = new boost::shared_ptr<T>;
        *this = rhs;
    }
    native_shared_ptr(const boost::shared_ptr<T>% rhs)
    {
        _spNative = new boost::shared_ptr<T>( rhs );
    }
    ~native_shared_ptr()
    {
        reset();
    }
    void reset()
    {
        delete _spNative;
        _spNative = nullptr;
    }
    T* operator->()
    {
        return _spNative->get();
    }
    operator bool()
    {
        return _spNative && *_spNative;
    }
    void operator=(const native_shared_ptr<T>% rhs)
    {
        *_spNative = *rhs._spNative;
    }
    void operator=(const boost::shared_ptr<T>% rhs)
    {
        *_spNative = rhs;
    }
protected:
    !native_shared_ptr()
    {
        reset();
    }
private:
    boost::shared_ptr<T>* _spNative;
};

I am quite happy :)

They hide new/delete jobs.
They are safe.
Their syntax is close to common smart-pointer, which is convenient.

The only issue is with the ctors with parameters... (TBD)

c++/cli wrapper for variable of native smart-pointer class

2 Answers