Эта проблема была исправлена и теперь вы можете обновить Docker и RPM соответственно.
Или что-то вроде этого:
Наследуйтесь своему notifier и добавьте Находящийся в собственности как шаблонный параметр. Затем можно иметь находящийся в собственности метод в наличии в notifier:
template < class Owner , class Owned >
class Notifier
{
public:
Notifier(Owner* owner)
{}
Owned * owned()
{ return static_cast< Owned * >( this ); }
~Notifier()
{
// notify owner with owned()
}
};
class Owner
{};
class Owned : public Notifier< Owner , Owned >
{
public:
Owned( Owner * owner ) : Notifier< Owner , Owned >( owner )
{}
};
Это было бы противным взломом и вероятно не гарантируемое работать, но здесь является мыслью, которую я не рекомендую этому.
Предположим, что у Вас есть свое расположение как Вы описанный как это:
template <class Owner>
class Notifier<Owner> {
public:
Notifier(Owner* owner);
~Notifier(); // Notifies the owner that an object is destroyed
};
class Owner;
class Owned {
public:
Owned(Owner* owner);
private:
Notifier<Owner> _notifier;
};
Если _notifier
знает его имя, оно могло вычислить Owned
обратитесь как это (который выполняется в Notifier
конструктор):
Owned *p = reinterpret_cast<Owned *>(reinterpret_cast<char *>(this) - offsetof(Owned, _notifier));
в основном предположение - то, что _notifier при некотором фиксированном смещении в Находящемся в собственности классе. Поэтому адрес Находящихся в собственности равен _notifier
адрес минус то же самое смещение.
Еще раз это - неопределенное поведение, которое я не рекомендовал бы, но мог возможно работать.
ответ.'s fa является хорошим началом. Однако это не разрешает проблему наличия нескольких владельцев того же типа. Одно решение состоит в том, чтобы иметь хранилище notifier список владельцев вместо единственного. Вот быстрая реализация, для показа идеи:
template <typename Owner, typename Owned>
class Notifier
{
protected:
Notifier()
{}
// Constructor taking a single owner
Notifier(Owner & o)
{
owners.push_back(&o);
}
// Constructor taking a range of owners
template <typename InputIterator>
Notifier(InputIterator firstOwner, InputIterator lastOwner)
: owners(firstOwner, lastOwner) {}
~Notifier()
{
OwnerList::const_iterator it = owners.begin();
OwnerList::const_iterator end = owners.end();
for ( ; it != end ; ++it)
{
(*it)->notify(static_cast<Owned*>(this));
}
}
// Method for adding a new owner
void addOwner(Owner & o)
{
owners.push_back(&o);
}
private:
typedef std::vector<Owner *> OwnerList;
OwnerList owners;
};
Можно использовать его этот путь:
class Owner;
class Owned : public Notifier<Owner, Owned>
{
typedef Notifier<Owner, Owned> base;
//Some possible constructors:
Owned(Owner & o) : base(o) { }
Owned(Owner & o1, Owner & o2)
{
base::addOwner(o1); //qualified call of base::addOwner
base::addOwner(o2); //in case there are other bases
}
Owned(std::list<Owner*> lo) : base(lo.begin(), lo.end()) { }
};
В случае, где у Вас есть много различных типов Владельцев, это решение может стать довольно трудным использовать. В этом случае Вы могли бы хотеть посмотреть на библиотеки метапрограммирования повышения (MPL, Fusion), с которым Вы могли закончить с кодом, которые позволяют Вам сделать материалы как этот:
class Owned : public Notifier<Owned, OwnerType1, OwnerType1, OwnerType2>
{
Owned(OwnerType1 & o1, OwnerType1 & o2, OwnerType2 & o3)
: base(o1,o2,o3)
};
Однако реализация этого решения была бы немного дольше, чем предыдущее.
Часть решения должна была бы Владеть, наследовались Notifier. Таким образом, адрес уничтоженного объекта - просто 'это'...
class Owned : public Notifier<Owner> {
public:
Owned(Owner* owner)
: Notifier<Owner>(owner)
{}
};
Но как обработать несколько 'владельцев' от того же класса? Как можно несколько раз наследоваться 'тому же классу'?
Благодаря ответу fa вот решение, которое я искал:
#include <iostream>
template <class Owner, class Owned, int = 0>
class Notifier {
public:
Notifier(Owner* owner)
: _owner(owner)
{}
~Notifier() {
_owner->remove(owned());
}
Owned * owned(){
return static_cast< Owned * >( this );
}
private:
Owner* _owner;
};
class Owner {
public:
void remove(void* any) {
std::cout << any << std::endl;
}
};
class Owned : public Notifier<Owner,Owned,1>, Notifier<Owner,Owned,2> {
public:
Owned(Owner* owner1, Owner* owner2)
: Notifier<Owner,Owned,1>(owner1)
, Notifier<Owner,Owned,2>(owner2)
{}
};
int main() {
std::cout << sizeof(Owned) << std::endl;
Owner owner1;
Owner owner2;
Owned owned(&owner1, &owner2);
std::cout << "Owned:" << (void*)&owned << std::endl << std::endl;
}
Спасибо!
Я высоко сомневаюсь относительно этого. Нет никакого пути к Notifier, чтобы знать, что он использовался в составе. Что, если я делаю
class Foo
{
private:
Notifier _a, _b, _c;
}
Я хотел бы быть доказанным неправым, хотя, но я действительно сомневаюсь, что это выполнимо, явно не давая больше информации Notifier.