那麼，std :: unique_ptr的定製刪除器如何工作？

Question

根據N3290 std::unique_ptr在其構造函數中接受deleter參數。

但是，我不能在Windows中使用Visual C++ 10.0或MinGW g ++ 4.4.1，也不能在Ubuntu中使用g ++ 4.6.1。

因此，我害怕我對它的理解是不完整或錯誤的，我無法看到明顯被忽略的刪除參數，所以任何人都可以提供一個工作示例？

最好我想看看它是如何工作的unique_ptr<Base> p = unique_ptr<Derived>(new Derived)。

可能使用標準中的一些措辭來備份示例，即使用您正在使用的任何編譯器，它實際上做了它應該做的事情？

Answer 1

這對我的作品在MSVC10

int x = 5; 
auto del = [](int * p) { std::cout << "Deleting x, value is : " << *p; }; 
std::unique_ptr<int, decltype(del)> px(&x, del); 

而且在GCC 4.5，here

我將跳過要標準，除非你不認爲例子是做什麼你」 d期待它做到。

Answer 2

This Works。破壞正常發生。

class Base 
{ 
    public: 
    Base() { std::cout << "Base::Base\n"; } 
    virtual ~Base() { std::cout << "Base::~Base\n"; } 
}; 


class Derived : public Base 
{ 
    public: 
    Derived() { std::cout << "Derived::Derived\n"; } 
    virtual ~Derived() { std::cout << "Derived::~Derived\n"; } 
}; 

void Delete(const Base* bp) 
{ 
    delete bp; 
} 

int main() 
{ 
    std::unique_ptr<Base, void(*)(const Base*)> ptr = std::unique_ptr<Derived, void(*)(const Base*)>(new Derived(), Delete); 
} 

Answer 3

我的問題已經很好地回答了。

但是爲了以防萬一人不知道，我有誤解，認爲一個unique_ptr<Derived>可以移動到unique_ptr<Base>，然後就記住了Derived對象缺失者，即是Base不會需要有一個虛析構函數。那是錯誤的。我選擇Kerrek SB's comment作爲「答案」，除了一個人不能這樣評論。

@Howard：下面的代碼說明了實現什麼，我相信一個動態分配的缺失者的成本不得不意味着unique_ptr支持開箱即用的方式之一：

#include <iostream> 
#include <memory>   // std::unique_ptr 
#include <functional>  // function 
#include <utility>   // move 
#include <string> 
using namespace std; 

class Base 
{ 
public: 
    Base() { cout << "Base:<init>" << endl; } 
    ~Base() { cout << "Base::<destroy>" << endl; } 
    virtual string message() const { return "Message from Base!"; } 
}; 

class Derived 
    : public Base 
{ 
public: 
    Derived() { cout << "Derived::<init>" << endl; } 
    ~Derived() { cout << "Derived::<destroy>" << endl; } 
    virtual string message() const { return "Message from Derived!"; } 
}; 

class BoundDeleter 
{ 
private: 
    typedef void (*DeleteFunc)(void* p); 

    DeleteFunc deleteFunc_; 
    void*  pObject_; 

    template< class Type > 
    static void deleteFuncImpl(void* p) 
    { 
     delete static_cast< Type* >(p); 
    } 

public: 
    template< class Type > 
    BoundDeleter(Type* pObject) 
     : deleteFunc_(&deleteFuncImpl<Type>) 
     , pObject_(pObject) 
    {} 

    BoundDeleter(BoundDeleter&& other) 
     : deleteFunc_(move(other.deleteFunc_)) 
     , pObject_(move(other.pObject_)) 
    {} 

    void operator() (void*) const 
    { 
     deleteFunc_(pObject_); 
    } 
}; 

template< class Type > 
class SafeCleanupUniquePtr 
    : protected unique_ptr< Type, BoundDeleter > 
{ 
public: 
    typedef unique_ptr< Type, BoundDeleter > Base; 

    using Base::operator->; 
    using Base::operator*; 

    template< class ActualType > 
    SafeCleanupUniquePtr(ActualType* p) 
     : Base(p, BoundDeleter(p)) 
    {} 

    template< class Other > 
    SafeCleanupUniquePtr(SafeCleanupUniquePtr<Other>&& other) 
     : Base(move(other)) 
    {} 
}; 

int main() 
{ 
    SafeCleanupUniquePtr<Base> p(new Derived); 
    cout << p->message() << endl; 
} 

乾杯，

Answer 4

爲了補充以前所有的答案，沒有辦法有一個定製刪除，而無需通過具有或者函數指針或等價的東西在裏面像這種「污染」了的unique_ptr簽名：

std::unique_ptr< MyType, myTypeDeleter > // not pretty 

這是通過提供專業化的標準:: default_delete模板類，像這樣實現的：

namespace std 
{ 
template<> 
class default_delete<MyType> 
{ 
public: 
    void operator()(MyType *ptr) 
    { 
    delete ptr; 
    } 
}; 
} 

現在所有std::unique_ptr<MyType>說，「看到」這種專業化將隨之被刪除。請注意，它可能不是您想要的所有std::unique_ptr<MyType>，所以請仔細選擇您的解決方案。