Làm thế nào để loại bỏ unique_ptr bởi con trỏ từ một container?

Question

Tạo đối tượng và cấp quyền sở hữu cho vùng chứa bằng cách sử dụng unique_ptr là không có vấn đề gì. Làm thế nào sẽ loại bỏ một yếu tố bằng con trỏ thô?

std::set<std::unique_ptr<MyClass>> mySet; 

MyClass *myClass = new MyClass(); 
mySet.insert(std::unique_ptr<MyClass>(myClass)); 

// remove myClass from mySet? 

Answer 1

Bạn sẽ cần phải tìm ra iterator tương ứng với các yếu tố myClass và sau đó vượt qua iterator rằng để mySet.erase(). Trình lặp có thể được tìm thấy bằng cách sử dụng thuật toán std::find_if với một tùy chỉnh Predicate functor hiểu cách dereference unique_ptr và so sánh nó với con trỏ thô myClass.

Bạn không thể sử dụng quá tải size_t set::erase (const key_type& x); vì con trỏ thô (ngay cả khi được bọc trong một unique_ptr tạm thời) sẽ không được tìm thấy trong mySet.

Answer 2

Không đẹp như tôi đã thích. Nhưng công việc sau đây thực hiện công việc:

#include <memory> 
#include <set> 
#include <iostream> 

struct do_nothing 
{ 
    void operator()(const void*) const {} 
}; 

struct MyClass 
{ 
    MyClass() {std::cout << "MyClass()\n";} 
    MyClass(const MyClass&) {std::cout << "MyClass(const MyClass&)\n";} 
    ~MyClass() {std::cout << "~MyClass()\n";} 
}; 

int main() 
{ 
    std::set<std::unique_ptr<MyClass>> mySet; 

    MyClass *myClass = new MyClass(); 
    mySet.insert(std::unique_ptr<MyClass>(myClass)); 

    // remove myClass from mySet? 
    std::set<std::unique_ptr<MyClass>>::iterator i = 
     lower_bound(mySet.begin(), mySet.end(), 
        std::unique_ptr<MyClass, do_nothing>(myClass)); 
    if (i != mySet.end() && *i == std::unique_ptr<MyClass, do_nothing>(myClass)) 
     mySet.erase(i); 
} 

Answer 3

Có vẻ như tôi có thể truy xuất trình lặp bằng cách sử dụng tùy chỉnh Predicate with lower_bound. Kể từ std :: set là một container theo thứ tự, lower_bound nên thực hiện logarithmically.

std::set<std::unique_ptr<MyClass>>::iterator i = 
    std::lower_bound(mySet.begin(), mySet.end(), myClass, MyPredicate<MyClass>()); 

template<class Type> 
struct MyPredicate 
{ 
    bool operator()(const std::unique_ptr<Type>& left, const Type* right) const 
    { 
     return left.get() < right; 
    } 
} 

Answer 4

Tuy không phải là giải pháp tốt nhất nhưng đối với thời điểm hiện tại tôi đi với:

PointerMap<MyFoo>::Type myFoos; 

MyFoo * myFoo = new MyFoo(); 
myFoos.insert(PointerMap<MyFoo>::Item(myFoo)); 

Các tiêu đề là:

#include <map> 
#include <memory> 
#include <utility> 

template<typename T> 
struct PointerMap 
{ 
    typedef std::map<T *, std::unique_ptr<T>> Type; 

    struct Item : std::pair<T *, std::unique_ptr<T>> 
    { 
     Item(T * pointer) 
      : std::pair<T *, std::unique_ptr<T>>(pointer, std::unique_ptr<T>(pointer)) 
     { 
     } 
    }; 
};