0

我有一个对象 ，BagOfThings它存储一组Things 和一个 s 列表BagOfThingsListener，它们想知道何时Thing添加或删除了BagOfThings它们已添加到的对象。像这样：

class Thing;
class BagOfThings;

class BagOfThingsListener {
public:
  virtual ~BagOfThingsListener() {}
  virtual void thingAdded(std::shared_ptr<BagOfThings> bag, std::shared_ptr<Thing> thing)=0;
  virtual void thingRemoved(std::shared_ptr<BagOfThings> bag, std::shared_ptr<Thing> thing)=0;
};

class BagOfThings: public enable_shared_from_this<BagOfThings> {
private:
  std::set<std::shared_ptr<Thing>> things;
  std::list<std::shared_ptr<BagOfThingsListener>> listeners;

private:
  BagOfThings() {}

public:
  static std::shared_ptr<BagOfThings> create() {
    return std::shared_ptr<BagOfThings>(new BagOfThings());
  }

  void addThing(std::shared_ptr<Thing> thing) {
    things.insert(thing);
    for (auto it=begin(listeners); it!=end(listeners); ++it) {
      (*it)->thingAdded(shared_from_this(), thing);
    }
  }

  void removeThing(std::shared_ptr<Thing> thing) {
    things.erase(thing);
    for (auto it=begin(listeners); it!=end(listeners); ++it) {
      (*it)->thingRemoved(shared_from_this(), thing);
    }
  }

  ~BagOfThings() {
    for (auto it=begin(things); it!=end(things);) {
      auto currentIt=it++;
      auto &currentThing=*currentIt;
      things.erase(currentIt);
      for (auto it2=begin(listeners); it2!=end(listeners); ++it2) {
        (*it2)->thingRemoved(shared_from_this(), currentThing);
      }
    }
  }
};

shared_from_this()这工作正常，除了析构函数，它是无效的，因为当所有shared_ptrs 都被销毁时，你不能使用，它们在调用析构函数时已经被销毁。在这种情况下，我使用的是共享指针，但在我看来，从析构函数中分发 this 指针无论如何都是有问题的——例如，有人可能会存储指针。thingAdded但是在这种情况下（希望让听众知道销毁所有元素的删除），如果不从听众中删除指向调用者的指针（即会变成） ，我看不到明显的好方法void thingAdded(std::shared_ptr<Thing>)。

有任何想法吗？

4

1 回答 1

0

为什么 BagOfThingsListener::thingAdded 和 BagOfThingsListener::thingRemoved 需要取一个 shared_ptr？对 BagOfThings 的引用/常量引用还不够吗？当 BagOfThings 调用 thingAdded 或 thingRemoved 时，您知道 this 指针有效，因此引用也将有效。

于 2013-02-27T12:04:46.243 回答