我有一个遵循这种模式的类：
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的循环，并且链接Foo都属于同一个Bar实例。目前为止，一切都好。为了以 C++11 的方式做事，我会在 Bar 中使用 vector< unique_ptr<Foo> > foos_;，并将foos_[i].get()作为 Foo 构造函数的潜在参数传递。
有交易：
这是一个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知道谁"依赖它们"，并且可以在删除之前通知他们（可能的解决方案详述 这里 和 这里 ）。
我的问题是：你会以同样的方式处理它吗？有没有办法使用标准的 C++11 智能指针来避免使用显式的反向指针，然后避免在 Foo 的析构函数中显式调用areRelativeToMe_[i]->convertToAbsolute();？我在想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跟踪自己的子指针（循环非拥有指针），但您也可以在 Bar 中跟踪它，或者按需搜索foos_以在需要时重新计算它。
即使对于多个其他依赖对象，也可以使用双链接方法。您只需将同一对象的依赖项链接在一起：
class Foo {
public:
explicit Foo(double x)
: v(x), foot(nullptr), next(nullptr), dept(nullptr) {}
// construct as relative object; complexity O(1)
Foo(Foo*f, double x)
: v(x), foot(f), dept(nullptr)
{ foot->add_dept(this); }
// destruct; complexity O(n_dept) + O(foot->n_dept)
// O(1) if !destroy_carefully
~Foo()
{
if(destroy_carefully) {
for(Foo*p=dept; p;) {
Foo*n=p->next;
p->unroot();
p=n;
}
if(foot) foot->remove_dept(this);
}
}
double x() const
{ return foot? foot->x() + v : v; }
private:
double v; // my position relative to foot if non-null
Foo*foot; // my foot point
Foo*next; // next object with same foot point as me
Foo*dept; // first object with me as foot point
// change to un-rooted; complexity: O(1)
void unroot()
{ v+=foot->x(); foot=nullptr; next=nullptr; }
// add d to the linked list of dependents; complexity O(1)
void add_dept(const Foo*d)
{ d->next=dept; dept=d; }
// remove d from the linked list of dependents ; complexity O(n_dept)
void remove_dept(const Foo*d)
{
for(Foo*p=dept; p; p=p->next)
if(p==d) { p=d->next; break; }
}
static bool destroy_carefully;
};
bool Foo::destroy_carefully = true;
在这里，设置 Foo::destroy_carefully=false 允许您删除所有剩余的对象，而无需解开相互引用（这可能很昂贵）。
有趣的问题。我猜你想你可以添加一个指向"子"对象的指针。我不确定，聪明的指针是否在这里有所帮助。我尝试使用 std::weak_ptr<Foo> 实现下面的代码，但您只能将其用于other_而不是侦听器。
我的另一个想法是把责任留给某个更高的权力。您遇到的问题是您希望在调用析构函数时执行更新。也许更好的方法是从其他地方打电话给convertToAbsolute()。例如，如果要将Foos存储在矢量中，并且用户在 UI 中单击"删除"，则需要对象的索引才能删除，因此不妨将相邻项更新为绝对值。
下面是使用Foo*的解决方案。
#include <iostream>
#include <memory>
#include <vector>
class Foo
{
public:
// Create a Foo whose value is absolute
Foo(int x) : other_(nullptr), listener_(nullptr), a_(x)
{}
// Create a Foo whose value is relative to another Foo
Foo(Foo* other, int dx) :
other_(other), listener_(nullptr), a_(dx)
{
other->setListener(this);
}
~Foo()
{
convertToAbsolute();
if (listener_)
listener_->other_ = nullptr;
}
// Get the value
double x() const
{
if(other_)
return other_->x() + a_;
else
return a_;
}
void setX(int i)
{
a_ = i;
}
void convertToAbsolute()
{
if (listener_)
listener_->a_ += a_;
}
void setListener(Foo* listener)
{
listener_ = listener;
}
private:
Foo* other_;
Foo* listener_;
int a_;
};
void printFoos(const std::vector<std::shared_ptr<Foo>>& foos)
{
std::cout << "Printing foos:n";
for(const auto& f : foos)
std::cout << 't' << f->x() << 'n';
}
int main(int argc, const char** argv)
{
std::vector<std::shared_ptr<Foo>> foos;
try
{
auto foo1 = std::make_shared<Foo>(42);
auto foo2 = std::make_shared<Foo>(foo1.get(), 42);
foos.emplace_back(foo1);
foos.emplace_back(foo2);
}
catch (std::exception& e)
{
std::cerr << e.what() << 'n';
}
// Here, foo1->x() = 42 and foo2->x() = 84
printFoos(foos);
foos[0]->setX(10);
// Here, foo1->x() = 10 and foo2->x() = 52
printFoos(foos);
foos.erase(foos.begin());
// Here, foo2->x() = 52
printFoos(foos);
return 0;
}
如果你有一个信号/插槽框架，这提供了一个很好的位置来取消链接。 例如，使用 Qt 库，这些类可能如下所示：
class Foo : public QObject
{
Q_OBJECT
public:
// Create a Foo whose value is absolute
Foo(int x) : QObject(nullptr), other_(nullptr), a_(x) {}
// Create a Foo whose value is relative to another Foo
Foo(Foo * other, int dx) : QObject(nullptr) other_(other), a_(dx) {
connect(other, SIGNAL(foo_dying()), this, SLOT(make_absolute()));
}
~Foo() { emit foo_dying(); }
// Get the value
double x() const
{
if(other_)
return other_->x() + a_;
else
return a_;
}
signals:
void foo_dying();
private slots:
void make_absolute()
{
a_ += other_->x();
other_ = nullptr;
}
private:
Foo * other_;
int a_;
};
这可能是使用后指针实现目标的最简单方法。您可以根据复杂性要求（例如，集合、哈希表、向量、链表等）使用所需的容器。沃尔特提出了一种更复杂但更有效的方法。
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)
{
other->areRelativeToMe_.insert(this);
}
// Get the value
double x() const
{
if(other_)
return other_->x() + a_;
else
return a_;
}
// delete the Foo
Foo::~Foo()
{
// Inform the one I depend on, if any, that I'm getting destroyed
if(other_)
other_->areRelativeToMe_.remove(this);
// Inform people that depends on me that I'm getting destructed
for(int i=0; i<areRelativeToMe_.size(); i++)
areRelativeToMe_[i]->convertToAbsolute();
}
private:
Foo * other_;
int a_;
Container<Foo*> areRelativeToMe_; // must provide insert(Foo*)
// and remove(Foo*)
// Convert to absolute
void convertToAbsolute()
{
a_ += other_->x();
other_ = 0;
}
};