विनाशकर्ता

Question

मैं निम्नलिखित सेटअप सही पाने के लिए कोशिश कर रहा हूँ की बुला आदेश लागू करने के लिए कैसे करें: (एकाधिक स्रोत फ़ाइलें, संकलन इकाइयों के साथ)

एक दिया आवेदन प्रकार class A कई संकलन इकाइयों में परिभाषित की वैश्विक चर है। इन्हें class B (जहां केवल 1 उदाहरण मौजूद होना चाहिए) को पेश करने के लिए नए द्वारा "प्रबंधित" होना चाहिए, इस अर्थ में कि वे कक्षा बी के उदाहरण पर और "विनाश" पर स्वयं को "पंजीकरण" करते हैं।

कन्स्ट्रक्टर के लिए काम करने के लिए चीज को सेट करना काफी सीधे है। एक का उपयोग कर सकते हैं:

types.h:

class B { 
    static B& Instance() { 
    static B singleton; 
    return singleton; 
    } 
    void registerA(const A& a) { 
    // whatever 
    } 
}; 


class A { 
    A() { B::Instance().registerA(this); } 
}; 

कैसे विनाशकर्ता सही पाने के लिए?

class A { 
    A() { B::Instance().registerA(this); } 
    ~A() { B::Instance().signoffA(this); } 
}; 

तो B का नाशक A का नाशक से पहले कहा जा सकता है: का उपयोग कर सकते हैं। फिर कक्षा A का उदाहरण B के एक नए नव निर्मित उदाहरण पर संकेत देता है।

file1.cc

#include "types.h" 
namespace C { 
    A a; 
} 

file2.cc

#include "types.h" 
namespace C { 
    A b; 
} 

मैं ऐसे कर सकते हैं पर लगता है:

परीक्षण का मामला एक नाम स्थान में class A के उदाहरण की परिभाषा के साथ एक बहु स्रोत फ़ाइल सेटअप होगा बूस्ट स्मार्ट पॉइंटर्स के साथ आसानी से चीज। हालांकि, यदि संभव हो तो मैं निर्भरता को यथासंभव कम रखने के लिए अतिरिक्त पुस्तकालयों का उपयोग करना टालना चाहूंगा।

एक चीज जो मदद कर सकती है: सभी वैश्विक चर नामित नामस्थान में हैं।

Answer 1

मुझे लगता है कि आप ठीक हैं। यहाँ "समाप्ति" पर 3.6.3 है:

निर्माता या स्थिर भंडारण अवधि के साथ एक वस्तु के गतिशील आरंभीकरण के पूरा होने के एक और की है कि इससे पहले कि अनुक्रम है, तो दूसरे के नाशक के पूरा होने से पहले अनुक्रम है पहले के विनाशक की शुरुआत।

मान लीजिए आप निम्नलिखित सेटअप:

struct A; 

struct B 
{ 
    static B & get() { static B impl; return impl; } 
    void registrate(A *); 

private: 
    B() { /* complex stuff */ } 
    // ... 
}; 

struct A { A() { B::get().registrate(this); } }; 

A a1; 

अब जो कुछ भी होता है, एक स्थिर A प्रकार वस्तु के पहले निर्माता B::get() है, जो पूरा होने से पहले स्थिर impl वस्तु के निर्माण के अनुक्रम कॉल करेंगे पहले A -कॉन्स्ट्रक्टर का। उपर्युक्त खंड से, यह गारंटी देता है कि B impl -object के विनाशक के बाद सभी A -destructors अनुक्रमित हैं।

Answer 2

B उदाहरण स्थैतिक है, इसलिए यह B सिंगलटन के निर्माण के बाद बनाए गए किसी भी A इंस्टेंस को बाहर कर देगा।