Custom Deactivator Smart Pointer

Question

For educational purposes only, I am writing a small class of smart pointers, not currently general, just as simple as unique_ptr in C ++ 11. What I want is not a fully working implementation, but just a base, create, default / custom delete, etc.

I am trying to look at the implementation of the standard inside the Microsoft visual studio, and I caught the general implementation, but I am stuck with default / user deletion. So my question is: what is the best way to implement such a function?

Can you easily implement it only for educational purposes, or in the end is it something too complicated and therefore not worth it?

amuses

Hi Ami,

what do you think of something like that?

template <class _Ty>
    struct default_delete
    {

        constexpr default_delete() = default;

        void operator()(_Ty* Ptr)
        {

        std::cout << "Default Delete" << std::endl;

        }

    };


template <class T, class _Dl=default_delete<T>>
            class Smart_Pointer2_Base;

    template <class T, class _Dl>
    class Smart_Pointer2_Base
    {
        T *ptr;  // Actual pointer
        _Dl _deleter;
    public:
        // Constructor
        explicit Smart_Pointer2_Base(T *p = NULL) { ptr = p; }

        Smart_Pointer2_Base(T* p, _Dl) { prt = p; _deleter = _Dl; }

        // Destructor
        ~Smart_Pointer2_Base() { _deleter(ptr);}

        // Overloading dereferencing operator
        T & operator * () { return *ptr; }


        T * operator -> () { return ptr; }
    };


int main()
{

    struct CloserStruct {
        void operator()(int* toDelete) { std::cout << "Custom Delete"<<std::endl; }
    };
    smtpr::Smart_Pointer2_Base<int, CloserStruct> pi(new int(5));

return 0;
}

Answer 1

type erasure. ++, (, boost::any), .

, :

struct deleter
{
    void operator()(void *)
    {
        cout << "deleting" << endl;
        // Do some other stuff.
    }
};

, .

:

struct base_deleter_holder
{
    virtual void delete_it(void *p) = 0;
};

.

, :

template<class Deleter>
struct deleter_holder :
    public base_deleter_holder
{
    Deleter m_d;

    explicit deleter_holder(const Deleter &d) : m_d(d)
    {}
    virtual void delete_it(void *p)
    {
        m_d(p);
    }
};

, :

template<class Deleter>
base_deleter_holder *make_deleter_holder(const Deleter &d)
{
    return new deleter_holder<Deleter>(d);
}

, - , . , :

    deleter d;

    // pd should be a member of your pointer class.
    base_deleter_holder *pd = make_deleter_holder(d);

    // Here how to use it.
    pd->delete_it(nullptr);

---

:

#include <functional> 
#include <iostream> 


using namespace std; 


struct base_deleter_holder 
{ 
    virtual void delete_it(void *p) = 0; 
}; 


template<class Deleter> 
struct deleter_holder :  
    public base_deleter_holder 
{ 
    Deleter m_d; 

    explicit deleter_holder(const Deleter &d) : m_d(d) 
    {} 
    virtual void delete_it(void *p) 
    { 
        m_d(p); 
    } 
}; 


struct deleter 
{ 
    void operator()(void *) 
    { 
        cout << "deleting" << endl; 
    } 
}; 


template<class Deleter> 
base_deleter_holder *make_deleter_holder(const Deleter &d) 
{ 
    return new deleter_holder<Deleter>(d); 
} 


int main() 
{ 
    deleter d; 
    base_deleter_holder *pd = make_deleter_holder(d); 
    pd->delete_it(nullptr); 
}