음, std :: unique_ptr의 사용자 지정

음, std :: unique_ptr의 사용자 지정

---

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 ).

예를 들어, 어떤 컴파일러를 사용하든 실제로 수행해야하는 작업을 수행한다는 것입니다.

---

이것은 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에서는 여기

그 예제가 당신이 기대하는 일을 정확히하고 생각하지 않는 한, 나는 표준으로가는 것을 건너는 것입니다.

---

이전의 모든 보완을 보완하기 위해 다음과 같이 함수 포인터 또는 이와 동등한 지정을 사용하여 unique_ptr 시그니처를 "오염"하지 않고 사용자 삭제 사용할 수 있습니다.

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

이는 다음과 같이 std :: default_delete 템플릿 클래스에 전문화를 제공하여 달성 할 수 있습니다.

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

이제이 std::unique_ptr< MyType >전문화를 "보는" 모든 항목 이 함께 삭제됩니다. 모두에게 원하는 것이 아닐 수도 std::unique_ptr< MyType >있으므로 신중하게 솔루션을 선택하십시오.

---

내 질문은 이미 꽤 잘 대답했습니다.

사람들이 궁금해 그러나 할 경우에 대비 unique_ptr<Derived>하여가 이동 될 수로 있다는 잘못된 믿음을 가지고 있었고 가상 소멸자가 필요하지 않은 object-의 삭제 unique_ptr<Base>자를 기억할 을 구석으로입니다. 그건 틀렸어요. Kerrek SB의 의견 을 "답변"으로 선택 하겠습니다 . 단, 의견에 그렇게 할 수 없습니다.DerivedBase

@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;
}

건배,

---

작동합니다. 파괴가 실제로 이루어집니다.

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);
}

참조 URL : https://stackoverflow.com/questions/8274451/well-how-does-the-custom-deleter-of-stdunique-ptr-work