मैं सी ++ में मालिक ऑब्जेक्ट का पता कैसे जान सकता हूं?

Question

मैं सी ++ एक नोटिफ़ायर क्लास में बनाना चाहता हूं जिसे ऑब्जेक्ट नष्ट होने पर विभिन्न धारकों को सूचित करने के लिए मैं अन्य ऑब्जेक्ट्स में उपयोग करूंगा।

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

मेरे बिंदु के रूप में मैं एक घने और जटिल वस्तु ग्राफ है, मैं सूचक में स्वामित्व वस्तु का पता भंडारण से बचना चाहते हैं। क्या मेरे नोटिफ़ायर क्लास को बदलने का कोई तरीका है ताकि वह स्वामित्व वाले ऑब्जेक्ट के पते को अपने पते से हटा दे और ऑफसेट जिसे संकलित समय पर गणना की जाएगी?

ध्यान दें कि किसी ऑब्जेक्ट को संभवतः उसी वर्ग से कई 'मालिकों' को सूचित करना पड़ सकता है।

धन्यवाद।

Answer 1

या कुछ इस तरह: अपने सूचक से

इनहेरिट और टेम्पलेट पैरामीटर के रूप में स्वामित्व जोड़ सकते हैं।

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

समाधान का हिस्सा नोटिफ़ायर से प्राप्त उत्तराधिकारी होना होगा। इस तरह, नष्ट वस्तु का पता बस है 'इस' ...

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

लेकिन यह कैसे एक ही कक्षा से कई 'मालिकों' को संभालने के लिए? 'एक ही कक्षा' से कई बार कैसे प्राप्त किया जा सकता है?

fa's answer के लिए धन्यवाद, यहाँ समाधान मैं खोज रहा था है:

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

धन्यवाद!

Answer 3

GoF Observer Design Patter पर एक नज़र डालें।

Answer 4

मुझे अत्यधिक संदेह है। नोटिफ़ायर को यह जानने का कोई तरीका नहीं है कि इसका उपयोग रचना में किया गया है। क्या होगा यदि मैं

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

कर रहा है, हालांकि गलत साबित किया जा करने में खुशी होगी, लेकिन मैं वास्तव में संदेह यह स्पष्ट रूप से सूचक के लिए अधिक जानकारी दिए बिना संभव है।

Answer 5

यह एक बुरा हैक हो सकता है और शायद काम करने के लिए गारंटी नहीं है, लेकिन यहां एक विचार मैं इस की सलाह नहीं देते है।

मान लीजिए कि आपके लेआउट की तरह आप इस तरह वर्णित: _notifier कि इसके नाम से जानता है

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

है, यह Owned 'इस तरह के पते (जो Notifier में निष्पादित किया जाता है के निर्माता) की गणना कर सकते हैं:

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

मूल रूप से, धारणा यह है कि _notifier स्वामित्व वाले वर्ग के भीतर कुछ निश्चित ऑफसेट पर है। इसलिए स्वामित्व का पता _notifier के पते के बराबर है जो उसी ऑफसेट से कम है।

एक बार फिर, यह अनिर्धारित व्यवहार है जिसे मैं अनुशंसा नहीं करता, लेकिन संभवतः काम कर सकता हूं।

Answer 6

fa.'s answer एक अच्छी शुरुआत है: तो फिर तुम एक स्वामित्व विधि सूचक के अंदर उपलब्ध हो सकता है। हालांकि, यह एक ही प्रकार के एकाधिक मालिकों की समस्या का समाधान नहीं करता है। एक समाधान यह है कि नोटिफ़ायर को एक के बजाय मालिकों की एक सूची स्टोर करना है।

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

मामले ऐसे हैं जिनमें मालिकों के विभिन्न प्रकार है, यह समाधान नहीं बल्कि मुश्किल हो सकता है उपयोग करने के लिए। होगा इस समाधान को लागू करने

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

हालांकि, इस मामले में, आप को बढ़ावा देने metaprogramming पुस्तकालयों (MPL, Fusion), जिसके साथ आप एक कोड आप ऐसा सामान करते हैं कि लग सकती है को देखने के लिए चाहते हो सकता है पिछले एक से थोड़ा लंबा हो।