我有一个遵循这种模式的类(class):

class Foo
{
public:
    // Create a Foo whose value is absolute
    Foo(int x) : other_(0), a_(x)  {}

    // Create a Foo whose value is relative to another Foo
    Foo(Foo * other, int dx) : other_(other), a_(dx) {}

    // Get the value
    double x() const
    {
        if(other_)
            return other_->x() + a_;
        else
            return a_;
    }

private:
    Foo * other_;
    int a_;
};

Foo对象都属于 Bar :

class Bar
{
public:
    ~Bar() { for(int i=0; i<foos_.size(); i++) delete foos_[i]; }

private:
    vector<Foo*> foos_;
};

当然，这是一个简化的例子来理解这个想法。我保证没有 Foo 的循环s，并链接Foo s 都属于 Bar 的同一个实例.到目前为止，一切都很好。要以 C++11 的方式做事，我会使用 vector< unique_ptr<Foo> > foos_;在 Bar , 并传递 foos_[i].get()作为 Foo 的潜在参数构造函数。

达成协议(protocol):

这是一个 GUI 应用程序，用户可以交互式地删除一些 Foo随意。预期的行为是如果 foo1被删除，foo2相对于 foo1 , 然后 foo2现在变成“绝对”:

void Foo::convertToAbsolute() { a_ += other_->x(); other_ = 0; }

void usageScenario()
{
    Foo * foo1 = new Foo(42);      
    Foo * foo2 = new Foo(foo1, 42);
    // Here, foo1->x() = 42 and foo2->x() = 84

    foo1->setX(10);
    // Here, foo1->x() = 10 and foo2->x() = 52

    delete foo1;
    // Here, foo2->x() = 52
}

我知道可以使用原始指针，通过使用带有反向指针的 DAG 结构来实现，所以 Foo知道谁“依赖他们”，并且可以在删除之前通知他们(可能的解决方案详述 here 和 here)。

我的问题是:您会以同样的方式处理吗？有没有办法使用标准 C++11 智能指针来避免显式反向指针，然后避免显式调用 areRelativeToMe_[i]->convertToAbsolute();在 Foo 的析构函数中？我在想 weak_ptr , 本着以下精神的东西:

class Foo { /* ... */ weak_ptr<Foo> other_; };

double Foo::x() const
{
    if(other_.isExpired())
        convertToAbsolute();

    // ...
}

但问题是 convertToAbsolute()需要亲戚Foo仍然存在。所以我需要一个非拥有的智能指针，它可以告诉“此引用逻辑上已过期”，但实际上会延长引用对象的生命周期，直到不需要它为止。

它可以被看作是 weak_ptr延长生命周期，直到不与任何其他人共享 weak_ptr :

class Foo { /* ... */ extended_weak_ptr<Foo> other_; };

double Foo::x() const
{
    if(other_.isExpired())
    {
        convertToAbsolute();
        other_.reset(); // now the object is destructed,  unless other
                          // foos still have to release it
    }

    // ...
}

或者像shared_ptr具有不同的所有权级别:

class Bar { /* ... */ vector< multilevel_shared_ptr<Foo> foos_; };

class Foo { /* ... */ multilevel_shared_ptr<Foo> other_; };

void Bar::createFoos()
{ 
    // Bar owns the Foo* with the highest level of ownership "Level1"

    // Creating an absolute Foo
    foos_.push_back( multilevel_unique_ptr<Foo>(new Foo(42), Level1) );

    // Creating a relative Foo 
    foos_.push_back( multilevel_unique_ptr<Foo>(new Foo(foos_[0],7), Level1) );
}

Foo::Foo(const multilevel_unique_ptr<Foo> & other, int dx) :
    other_( other, Level2 ),
   // Foo owns the Foo* with the lowest level of ownership "Level2"
    a_(dx) 
{
}

double Foo::x() const
{
    if(other_.noLevel1Owner()) // returns true if not shared 
                               // with any Level1 owner
    {
        convertToAbsolute();
        other_.reset(); // now the object is destructed, unless 
                        // shared with other Level2 owners
    }
    // ...
}

有什么想法吗？

最佳答案

所有 Foo 都属于 Bar。因此，所有 Foo 的删除都发生在 Bar 方法中。所以我可能会在 Bar 中实现这个逻辑:

void Bar::remove(Foo* f)
{
    using namespace std::placeholders;
    assert(std::any_of(begin(foos_), end(foos_),
                       std::bind(std::equal_to<decltype(f)>(), f, _1));

    auto const& children = /* some code which determines which other Foo depend on f */;
    std::for_each(begin(children), end(children),
                  std::mem_fn(&Foo::convertToAbsolute));
    foos_.remove(f);

    delete f; // not needed if using smart ptrs
}

这将确保在 convertToAbsolute 对其依赖项调用时，过期的 Foo 仍然存在。

如何计算 children 由您决定。我可能会让每个 Foo 跟踪它自己的 child (循环非拥有指针)，但你也可以在 Bar 中跟踪它，或者通过 搜索>foos_ 按需在需要时重新计算它。

关于c++ - 存储非拥有引用的对象，在销毁引用之前必须通知该引用，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/18774718/