如何摆脱容器中的weak_ptrs

Question

我有一个类将weak_ptr 存储在容器中，如果weak_ptr 未过期，稍后会执行一些操作：

class Example
{
public:
    void fill(std::shared_ptr<int> thing)
    {
        member.push_back(thing);
    }
    void dosomething() const
    {
        for (const auto& i : member)
            if (!i.expired())
                ;// do something. the weak_ptr will not be locked
    }
private:
    std::vector<std::weak_ptr<int>> member;
};

如果Example 是一个永远存在的对象并且fill 被定期使用，则向量会连续为元素分配内存，但它们在过期后永远不会被删除。

是否有任何自动的 C++ 方法来摆脱容器中过期的weak_ptrs，或者是否有更好的方法来存储可变数量的它们？

我幼稚的方法是每次调用fill 时遍历容器并删除所有过期的weak_ptrs。在Example 在容器中有很多元素并且经常调用填充的情况下，这似乎非常低效。

Answer 1

由于您澄清您实际上使用的是std::map 而不是std::vector，因此在doSomething() 中即时删除过期元素可能是最简单的。从基于范围的 for 循环切换回基于普通迭代器的设计：

void dosomething() const
{
    auto i = member.begin();
    while( i != member.end() ) {
      if( i->expired() ) { i = member.erase( i ); continue; }
      ;// do something. the weak_ptr will not be locked
      ++i;
    }
}

Answer 2

shared_ptr<int> 必须是 shared_ptr<int> 吗？

shared_ptr<IntWrapper> 怎么样？

#include <iostream>
#include <forward_list>
using namespace std;

class IntWrapper {
public:
    int i;

    static forward_list<IntWrapper*>& all() {
        static forward_list<IntWrapper*> intWrappers;
        return intWrappers;
    }
    IntWrapper(int i) : i(i)  {
        all().push_front(this);
    }
    ~IntWrapper() {
        all().remove(this);
    }
};

void DoSomething() {
    for(auto iw : IntWrapper::all()) {
        cout << iw->i << endl;
    }
}

int main(int argc, char *argv[]) {
    shared_ptr<IntWrapper> a = make_shared<IntWrapper>(1);
    shared_ptr<IntWrapper> b = make_shared<IntWrapper>(2);
    shared_ptr<IntWrapper> c = make_shared<IntWrapper>(3);
    DoSomething();
    return 0;
}

Answer 3

我宁愿为 shared_ptr 使用自定义删除器。但这意味着这里要更改 Example 类的接口。使用自定义删除器的优点是无需检查集合中的过期对象。该集合由自定义删除器直接维护。

快速实施：

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

template <typename Container>
// requires Container to be an associative container type with key type
// a raw pointer type
class Deleter {
    Container* c;
public:
    Deleter(Container& c) : c(&c) {}
    using key_type = typename Container::key_type;
    void operator()(key_type ptr) {
        c->erase(ptr);
        delete ptr;
    }
};

class Example {
public:
    // cannot change the custom deleter of an existing shared_ptr
    // so i changed the interface here to take a unique_ptr instead
    std::shared_ptr<int> fill(std::unique_ptr<int> thing) {
        std::shared_ptr<int> managed_thing(thing.release(), Deleter<containter_type>(member));
        member.insert(managed_thing.get());
        return managed_thing;
    }

    void dosomething() const {
        // we don't need to check for expired pointers
        for (const auto & i : member)
            std::cout << *i << ", ";

        std::cout << std::endl;
    }

    using containter_type =  std::set<int*>;
private:
    containter_type member;
};

int main()
{
    Example example;
    auto one = example.fill(std::unique_ptr<int>(new int(1)));
    auto two = example.fill(std::unique_ptr<int>(new int(2)));
    auto three = example.fill(std::unique_ptr<int>(new int(3)));
    example.dosomething();
    three.reset();
    example.dosomething();
}