Объект, хранящий не владеющую ссылку, которая должна быть проинформирована перед уничтожением ссылки

Вы можете использовать подход двойной ссылки даже с более чем одним другим зависимым объектом. Вам нужно только связать вместе зависимости одного и того же объекта:

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 позволяет удалить все оставшиеся объекты, не проходя распутывание взаимных ссылок (что может быть дорогостоящим).

Интересная проблема. Полагаю, вы поняли, что можете добавить указатель на объект ‘child’. Я не уверен, помогают ли умные указатели здесь. Я попытался реализовать код ниже, используя std::weak_ptr<Foo> но вы можете использовать его только для other_ и не для слушателя.

Еще одна мысль, которая у меня была, — это передать ответственность некой высшей силе. Проблема в том, что вы хотите выполнить обновление при вызове деструктора. Возможно, лучшим подходом будет позвонить convertToAbsolute() откуда-то еще Например, если вы храните Foos в векторе, и пользователь нажимает кнопку «удалить» в пользовательском интерфейсе, для удаления требуется индекс объекта, поэтому можно также обновить соседний элемент до абсолютного значения.

Ниже приведено решение, которое использует 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;
}

Если у вас есть платформа Signal / Slot, это хорошее место для отвязки. Например, используя библиотеки 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;
}
};