Wie kann ich die Adresse des Besitzerobjekts in C++ wissen?

Question

Ich möchte in C++ eine Notifier-Klasse erstellen, die ich in anderen Objekten verwenden werde, um verschiedene Halter zu benachrichtigen, wenn das Objekt zerstört wird.

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; 
}; 

Mein Punkt ist, dass ich ein dichtes und komplizierte Objektgraphen habe, würde ich in dem Anmelder die Adresse des im Besitz Objekts vermeiden möge zu speichern. Gibt es eine Möglichkeit, meine Benachrichtigungsklasse so zu ändern, dass sie die Adresse des eigenen Objekts von seiner eigenen Adresse und einem Offset ableiten kann, der zur Kompilierzeit berechnet wird?

Beachten Sie auch, dass jedes Objekt möglicherweise mehrere "Eigentümer" melden muss, möglicherweise aus der gleichen Klasse.

Danke.

Answer 1

Oder so etwas wie:

Vererben von Ihrem Anmelder und fügen Sie als Template-Parameter gehört.Dann können Sie eine prozentige Methode innerhalb der Anmelder zur Verfügung haben:

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) 
    {} 
}; 

Answer 2

Ein Teil der Lösung wäre, dass der Besitz von Notifier erben würde. Auf diese Weise wird die Adresse des Objekts zerstört ist einfach ‚this‘ ...

class Owned : public Notifier<Owner> { 
public: 
    Owned(Owner* owner) 
    : Notifier<Owner>(owner) 
    {} 
}; 

Aber wie aus der gleichen Klasse mehr ‚Besitzer‘ zu behandeln? Wie kann man mehrfach von der 'selben Klasse' erben?

Dank fa's answer, hier ist die Lösung, die ich suchte:

#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; 
} 

Dank!

Answer 3

Werfen Sie einen Blick auf die GoF Observer Design Patter.

Answer 4

Ich bezweifle es sehr. Der Notifier kann nicht wissen, dass er in der Zusammensetzung verwendet wurde. Was passiert, wenn ich

class Foo 
{ 
private: 
    Notifier _a, _b, _c; 
} 

tun würde ich gerne obwohl falsch bewiesen werden, aber ich bezweifle wirklich, ohne explizit zu geben weitere Informationen zu den Notifier machbar ist.

Answer 5

Es wäre ein bösen Hack und wahrscheinlich nicht garantiert werden, aber hier ist ein Gedanke ich diese nicht empfehlen.

Angenommen, Sie haben Ihr Layout wie Sie wie folgt beschrieben:

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; 
}; 

Wenn _notifier seinen Namen kennt, könnte es Owned ‚s-Adresse wie folgt aus (die in der Notifier ausgeführt wird‘ berechnen Konstruktor):

Owned *p = reinterpret_cast<Owned *>(reinterpret_cast<char *>(this) - offsetof(Owned, _notifier)); 

Grundsätzlich ist die Annahme, dass _notifier bei einigen festen Offset innerhalb der Owned-Klasse ist. Daher ist die Adresse von Owned gleich _notifiers Adresse abzüglich des gleichen Offsets.

Noch einmal, dies ist undefiniertes Verhalten, das ich nicht empfehlen würde, aber möglicherweise funktionieren könnte.

Answer 6

fa.'s answer ist ein guter Anfang. Es löst jedoch nicht das Problem, mehrere Besitzer desselben Typs zu haben. Eine Lösung besteht darin, dass der Anmelder eine Liste von Besitzern anstatt einer einzigen speichert. Hier ist eine schnelle Implementierung ist, die Idee zu zeigen:

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; 
}; 

Sie können es auf diese Weise verwenden:

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()) { } 
}; 

In dem Fall, dass Sie viele verschiedene Arten von Eigentümer haben, kann diese Lösung wird ziemlich schwierig benutzen. In diesem Fall sollten Sie bei den Boost-metaprogramming Bibliotheken suchen (MPL, Fusion), mit dem Sie mit einem Code könnte am Ende, dass Sie so tun stopft lassen:

class Owned : public Notifier<Owned, OwnerType1, OwnerType1, OwnerType2> 
{ 
    Owned(OwnerType1 & o1, OwnerType1 & o2, OwnerType2 & o3) 
     : base(o1,o2,o3) 
}; 

jedoch die Implementierung dieser Lösung würde etwas länger sein als die vorherige.