Re: RAII pointers

[Stanislav Blinov via Digitalmars-d-learn]

On Monday, 29 May 2017 at 23:39:17 UTC, Russel Winder wrote:
C++ allows one to create types that are pointer types but wrap 
a primitive pointer to give RAII handling of resources. For 
example:


    class Dvb::FrontendParameters_Ptr {
    private:
            dvb_v5_fe_parms * ptr;
    public:
    	    FrontendParameters_Ptr(FrontendId const & fei, 
unsigned int const verbose = 0, unsigned int const legacy = 0);
    	    FrontendParameters_Ptr(FrontendParameters_Ptr const &) 
= delete;
    	    FrontendParameters_Ptr & 
operator=(FrontendParameters_Ptr const &) = delete;
            ~FrontendParameters_Ptr() {dvb_fe_close(ptr); }
            dvb_v5_fe_parms * c_ptr() const { return ptr; }
            dvb_v5_fe_parms * operator->() const { return ptr; }
    };


Has anyone any experience of doing the analogous thing 
idiomatically in D.

I just re-realised I manually constructed a C++ abstraction 
layer around some of libdvbv5, so I am going to do the same for 
D. However whilst I (sort of) understand doing the wrapping 
with C++, I am not sure I have seen anyone wrapping C pointers 
with RAII in D.

I've found this pattern works rather well:

module frontendparametersptr;

struct FrontendParametersPtr
{
    // No constructors, initialization with parameters
    // is done via the frontendParametersPtr function
    @disable this(this);

    ~this()
    {
        // null check is often useful to detect e.g.
        // if this object has been `move`d
        if (_ptr) dvb_fe_close(_ptr);
    }

    // with DIP1000, could also return `scope`
    inout(dvb_v5_fe_parms)* ptr() inout { return _ptr; }
    alias ptr this;
package:

    void construct(/*your args here*/) { /*...*/ }

private:
    dvb_v5_fe_parms* _ptr;
}

/// Replaces constructor, i.e. can be called with no arguments for
/// replacing "default" construction of C++
auto frontendParametersPtr(Args...)(auto ref Args args)
{
    import std.functional : forward;
    FrontendParametersPtr result = void;
    result.construct(forward!args);
    return result; // moves result, no copy is made
}

///-----

module app;

import frontendparametersptr;

void main()
{
    auto ptr = frontendParametersPtr(/* your args here */);
}


The main idea is that construction is handled by the `construct` 
function (which could be overloaded), instead of `this(...)` 
constructors: this way client code would either get 
default-initialized (.init) pointers, or those constructed with 
appropriate arguments (even with no arguments, if such is needed).
Disabling copying is obvious.
The rest depends on taste and purpose.