संरचना

Question

में लूज युग्मन मुझे ढीले युग्मन को समझने में मदद की ज़रूरत है। संरचना को कम से कम युग्मित करने के लिए एक कक्षा को कैसे डिज़ाइन किया जाता है, जब किसी बच्चे को ऑब्जेक्ट को को उनके मूल ऑब्जेक्ट के साथ संवाद करने की आवश्यकता होती है? मुझे एक उदाहरण देता हूँ:

class A { 
    private: 
     B b; 
    public: 
     void foo(); 
}; 

कैसे बी वस्तु अपने कंटेनर वर्ग एक से समारोह foo() फोन करता है:

हम इस किया है? स्पष्ट जवाब है "बस ए से बी तक एक पॉइंटर पास करें", लेकिन यह तंग युग्मन और एक लचीला डिजाइन है।

क्या आप कृपया मुझे इस समस्या का समाधान कर सकते हैं (सी ++ या जावा में अधिमानतः) या इन तकनीकों से निपटने वाली डिज़ाइन तकनीकों को प्रदान करें?

मेरा असली जीवन उदाहरण जेआरपीजी के लिए एक गेम इंजन विकसित करने से आता है। हर खेल पाश, StateMachine की Update() कहा जाता है जो curState की Update() फ़ंक्शन को कॉल करने में

class StateMachine 
{ 
    private: 
     std::map<std::string, State*> states; 
     State* curState; 
    public: 
     StateMachine(); 
     ~StateMachine(); 
     void Update(); 
     void Render(); 
     void ChangeCurState(const std::string& stateName); 
     void AddState(const std::string& stateName, State* state); 
}; 

: मैं इस वर्ग की है। मैं curStateChangeCurState StateMachine कक्षा से कॉल करने में सक्षम हूं, लेकिन ढीले युग्मन के साथ।

Answer 1

में एक वस्तु की जरूरत है आप इंटरफेस का उपयोग कर दसगुणा कर सकते हैं।

एक इंटरफ़ेस F बनाएँ जो foo() विधि लागू करता है और इसे बी में पास करता है। एक F लागू करें। अब ख जानने या यहाँ तक कि देखभाल यह ए

Answer 2

इस स्थिति में युग्मन को कम करने का एक तरीका उन वस्तुओं के लिए इंटरफेस को परिभाषित करना है जो रचना में उपयोग किए जाएंगे। यह सुनिश्चित करता है कि उनके कार्यान्वयन में कोई भी बदलाव कुछ भी तोड़ नहीं देगा, बशर्ते वे आपके द्वारा परिभाषित इंटरफ़ेस को बनाए रखें। यदि आप संरचना के लिए इंटरफेस पर निर्भर करते हैं, तो आप पाएंगे कि आप हमेशा अपने अन्य वर्गों को तोड़ने के बिना अपने कार्यान्वयन को बदल सकते हैं।

Answer 3

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

अपने कोड refactor अगर आप पूरी तरह से पूरे बी

Answer 4

शायद यह (जावा) की तरह कुछ द्वारा कार्यान्वित किया जाता बिना एफ पर foo() कॉल कर सकते हैं:

public interface A { 
    void foo(); 
} 

public interface B { 
    ... 
} 

public class BImpl implements B { 
    public B(A a) { ... } 
    ... 
} 

public class AImpl implements A { 
    private B b = new BImpl(this); 
    ... 
} 

Answer 5

अपने डिजाइन के बारे में सोचो। कैसे ए और बी संबंधित हैं i.e. यदि बी ए का हिस्सा है तो संरचना ठीक है। मूल रूप से, वहाँ कुछ तरीके बताए गए अन्य वर्ग 1. उपयोग कर सकते हैं में उत्तीर्ण होकर कर रहे हैं संदर्भ 2. रचना/विरासत 3. मित्र वर्ग

Answer 6

अपने अद्यतन मैं तुम्हें एक अलग जवाब दे देंगे को देखते हुए।

मैं चार विकल्प

1. के बारे में सोच सकते हैं कि प्रत्येक State में StateMachine का एक उदाहरण दर्रा और इसके बारे में चिंता मत करो।यह उन्हें एक साथ जोड़ता है लेकिन यह तर्क दिया जा सकता है कि वे वैसे भी कड़े से जुड़े हुए हैं।

2. के रूप में उल्लेख किया गया है एक अंतरफलक जो सिर्फ इतना है कि आप State को दिखाई और State में इस पास करना चाहते हैं StateMachine पर तरीकों शामिल पैदा करते हैं। यह एक सुधार है क्योंकि अब आप State को StateMachine कक्षा में कर सकते हैं।

3. पर्यवेक्षक/पर्यवेक्षक का उपयोग भी उल्लेख किया गया है। यहां आपके State ईवेंट बनाएंगे और उन्हें सभी पर्यवेक्षकों को आग लगा दी जाएगी। इस मामले में आपके StateMachine को अपने सभी State एस का पालन करना होगा और तदनुसार प्रतिक्रिया देना होगा। यह पूरी तरह से मान्य है, लेकिन शायद थोड़ा सा जटिल, निश्चित रूप से शुरू करने के लिए।

4. एक अन्य दृष्टिकोण EventBus जैसे कुछ का उपयोग करना है, जिसे StateMachine द्वारा बनाया गया है और प्रत्येक State में पारित किया गया है। State घटना बस पर घटनाओं को आग लग सकता है। StateMachine ईवेंट बस पर ईवेंट सुन सकते हैं और तदनुसार प्रतिक्रिया दे सकते हैं। यह पर्यवेक्षक पैटर्न का एक सरलीकरण है।