इंटरफेस और कार्यान्वयन डिजाइन संरचना?

Question

मैं सी ++ में बड़े कार्यक्रमों को डिजाइन करने के लिए काफी नया हूं। मैं संचालन की श्रृंखला लिख ​​रहा हूं, जिनमें से प्रत्येक का अपना वर्ग है, जिसे ProcessMgr वर्ग द्वारा बुलाया जाएगा।

मैं एक इंटरफ़ेस वर्ग है, जिससे प्रत्येक कार्रवाई को निरस्त किया जा सकता है के रूप में ProcessMgr उपयोग कर रहा हूँ:

class ProcessMgr 
{ 
private: 
    class OperationOne; 
    class OperationTwo; 
    class OperationThree; 
} 

class ProcessMgr::OperationOne 
{ 
public: 
    ... 
}; 
class ProcessMgr::OperationTwo 
{ 
public: 
    ... 
}; 
class ProcessMgr::OperationThree 
{ 
public: 
    ... 
}; 

यह Operation कक्षाओं के लिए उपयोग के प्रकारों को नियंत्रित करने के लिए मुझे सक्षम बनाता है, इसलिए उनके अंतर्निहित के ज्यादा उजागर नहीं कोड।

ऐसा नहीं है कि इस कोड के उपयोगकर्ता केवल विशिष्ट तरीके से Operation वर्गों के साथ बातचीत कर सकते हैं और Operations कक्षाओं की सभी सामग्री के लिए पूर्ण पहुँच नहीं महत्वपूर्ण है।

मेरे सवालों का:

1) इस बड़े कार्यक्रमों को डिजाइन करने के लिए एक अच्छा दृष्टिकोण है? क्या अधिकांश पुस्तकालय, जैसे कि कर्ल, इस तरह से संरचित हैं?

2) क्या इंटरफ़ेस और कार्यान्वयन को अलग करने के बेहतर/अधिक कुशल तरीके हैं?

Answer 1

सी ++ (या अन्य ओओपी भाषाओं) में एक सामान्य इंटरफेस परिभाषा प्रदान करता है। "ऑपरेशन-क्लास" को इंटरफ़ेस से लिया जाना चाहिए, ताकि आप क्लाइंट से कार्यान्वयन को रद्द कर सकें। इस सिद्धांत को Dependency inversion principle(DIP) कहा जाता है।

DIP से एक आम यूएमएल-आरेख ऐसा दिखाई देता है:

के बाद से ग्राहक बस इंटरफ़ेस से परिचित है, तो आप विशिष्ट उपवर्गों तक पहुँच को नियंत्रित कर सकते हैं। एक कार्यान्वयन ऐसा दिखाई दे सकता:

class ProcessMgr { 
    virtual void foo() = 0; 
    virutal void bar() = 0; 
} 

class Operation1 : public ProcessMgr { 
    virtual void foo() { ... } 
    virtual void bar() { ... } 
} 

class Operation2 : public ProcessMgr { 
    virtual void foo() { ... } 
    virtual void bar() { ... } 
} 

DIP बहुत अच्छा सिद्धांतों की एक श्रृंखला, SOLID कहा जाता है से एक सिद्धांत है। बड़ी परियोजनाओं को डिजाइन करने के लिए, करने और सीखने के लिए बहुत कुछ है। लेकिन सॉलिड-सिद्धांत यह समझने के लिए एक अच्छी शुरुआत है कि सॉफ्टवेयर अनुप्रयोगों को कैसे डिजाइन किया जाए।