Question

仅出于教育目的，我正在编写一个小型的智能指针类，目前不是一个共享的类，只是像C ++ 11中的unique_ptr那样简单。我想要的不是一个完全有效的实现，而只是基础，创造，默认/自定义删除等。

我一直在尝试查看Microsoft visual studio内部标准的实现，我确实抓住了一般实现但是我被卡住了使用默认/自定义删除。所以我的问题是，实现这样一个功能的最佳技术是什么？

有可能只是为了教育目的而轻松实现它，或者最终它太复杂而且不值得？

欢呼声

嗨阿米，

你怎么看待这样的事情？

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的东西。虽然有C ++库可以做到这一点（例如，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's 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); 
}

智能指针自定义删除器

1 个答案: