实战c++中的智能指针unique_ptr系列-- unique_ptr的get_deleter方法(自定义删除器)

unique_ptr的成员函数在上一篇博客中几乎全部涵盖，其实还有一个很有踢掉，即std::unique_ptr::get_deleter

字面已经很明显了，就获得deleter：
Returns the stored deleter

The stored deleter is a callable object. A functional call to this object with a single argument of member type pointer is expected to delete the managed object, and is automatically called when the unique_ptr is itself destroyed, assigned a new value, or resetted while non-empty.

直接看例子：

#include 
#include 

class state_deleter {  // a deleter class with state
    int count_;
public:
    state_deleter() : count_(0) {}
    template 
    void operator()(T* p) {
        std::cout << "[deleted #" << ++count_ << "]\n";
        delete p;
    }
};

int main() {
    state_deleter del;

    std::unique_ptr p;   // uses default deleter

    // alpha and beta use independent copies of the deleter:
    std::unique_ptr alpha(new int);
    std::unique_ptr beta(new int, alpha.get_deleter());
    return 0;
}

运行程序，输出结果：
[deleted #1]
[deleted #1]
说明了，在函数结束的时候，alpha beta的析构函数被调用了，而且析构函数是我们自己定义的类。

在上面的代码上加入对alpha beta的操作：

int main() {
    state_deleter del;

    std::unique_ptr p;   // uses default deleter

    // alpha and beta use independent copies of the deleter:
    std::unique_ptr alpha(new int);
    std::unique_ptr beta(new int, alpha.get_deleter());


    std::cout << "resetting alpha..."; alpha.reset(new int);
    std::cout << "resetting beta..."; beta.reset(new int);

    return 0;
}

输出：
resetting alpha…[deleted #1]
resetting beta…[deleted #1]
[deleted #2]
[deleted #2]
说明在reset方法后，也调用了自定义的析构~

再继续添加代码：

#include 
#include 

class state_deleter {  // a deleter class with state
    int count_;
public:
    state_deleter() : count_(0) {}
    template 
    void operator()(T* p) {
        std::cout << "[deleted #" << ++count_ << "]\n";
        delete p;
    }
};

int main() {
    state_deleter del;

    std::unique_ptr p;   // uses default deleter

                              // alpha and beta use independent copies of the deleter:
    std::unique_ptr alpha(new int);
    std::unique_ptr beta(new int, alpha.get_deleter());

    // gamma and delta share the deleter "del" (deleter type is a reference!):
    std::unique_ptr gamma(new int, del);
    std::unique_ptr delta(new int, gamma.get_deleter());

    std::cout << "resetting alpha..."; alpha.reset(new int);
    std::cout << "resetting beta..."; beta.reset(new int);
    std::cout << "resetting gamma..."; gamma.reset(new int);
    std::cout << "resetting delta..."; delta.reset(new int);

    return 0;
}

输出：
resetting alpha…[deleted #1]
resetting beta…[deleted #1]
resetting gamma…[deleted #1]
resetting delta…[deleted #2]
[deleted #3]
[deleted #4]
[deleted #2]
[deleted #2]
这里我们重点关注delta，这里使用的是按引用传递。
还有一个地方需要说明：
析构的顺序与构造的顺序相反~~

go on:

#include 
#include 

class state_deleter {  // a deleter class with state
    int count_;
public:
    state_deleter() : count_(0) {}
    template 
    void operator()(T* p) {
        std::cout << "[deleted #" << ++count_ << "]\n";
        delete p;
    }
};

int main() {
    state_deleter del;

    std::unique_ptr p;   // uses default deleter

                              // alpha and beta use independent copies of the deleter:
    std::unique_ptr alpha(new int);
    std::unique_ptr beta(new int, alpha.get_deleter());

    // gamma and delta share the deleter "del" (deleter type is a reference!):
    std::unique_ptr gamma(new int, del);
    std::unique_ptr delta(new int, gamma.get_deleter());

    std::cout << "resetting alpha..."; alpha.reset(new int);
    std::cout << "resetting beta..."; beta.reset(new int);
    std::cout << "resetting gamma..."; gamma.reset(new int);
    std::cout << "resetting delta..."; delta.reset(new int);

    //std::cout << "calling gamma/delta deleter...";
    gamma.get_deleter()(new int);

    alpha.get_deleter() = state_deleter(); // a brand new deleter for alpha

                                            // additional deletions when unique_ptr objects reach out of scope
                                            // (in inverse order of declaration)

    return 0;
}

此时输出：
//输出：
//resetting alpha…[deleted #1]
//resetting beta…[deleted #1]
//resetting gamma…[deleted #1]
//resetting delta…[deleted #2]
//calling gamma / delta deleter…
//[deleted #3]
//[deleted #4]
//[deleted #5]
//[deleted #2]
//[deleted #1]

最后再来一个：

#include   
#include   

using namespace std;

void deleter(int* ptr) {
    delete ptr;
    ptr = nullptr;
    std::clog << "shared_ptr delete the pointer." << std::endl;
}

int main(void) {

    //定义函数类型  
    typedef void(*tp) (int*);
    typedef decltype (deleter)* dp;
    using up = void(*) (int*);

    std::shared_ptr spi(new int(10), deleter);
    std::shared_ptr spi2(new int, deleter);
    spi2 = std::make_shared(15);

    std::cout << "*spi = " << *spi << std::endl;
    std::cout << "*spi2 = " << *spi2 << std::endl;

    //unique_ptr是模板函数需要删除器(deleter)类型, 再传入具体的删除器  
    std::unique_ptr upi(new int(20), deleter);
    std::unique_ptr upi2(new int(25), deleter);
    std::unique_ptr upi3(new int(30), deleter);
    std::unique_ptr upi4(new int(35), deleter);

    std::cout << "*upi = " << *upi << std::endl;
    std::cout << "*upi2 = " << *upi2 << std::endl;
    std::cout << "*upi3 = " << *upi3 << std::endl;
    std::cout << "*upi4 = " << *upi4 << std::endl;

    return 0;

}
//输出：
//shared_ptr delete the pointer.
//*spi = 10
//* spi2 = 15
//* upi = 20
//* upi2 = 25
//* upi3 = 30
//* upi4 = 35
//shared_ptr delete the pointer.
//shared_ptr delete the pointer.
//shared_ptr delete the pointer.
//shared_ptr delete the pointer.
//shared_ptr delete the pointer.

只是分析这两句：

std::shared_ptr spi2(new int, deleter);
spi2 = std::make_shared(15);

这时候会调用deleter删除器！