क्या कक्षा में दो सार्वजनिक अनुभाग हो सकते हैं? यदि हां तो क्यों? और किस परिस्थितियों में हम ऐसा करते हैं?

Question

कक्षाओं के बारे में मुझे कुछ परेशान कर रहा है। उदाहरण के लिए

class A 
{ 
public: 
    A() 
    { 
    ..... 
    ..... 
    } 

    void cleanup() 
    { 
    .... 
    .... 
    .... 
    } 

public: 
    UINT a; 
    ULONG b; 
}; 

उपर्युक्त उदाहरण में दो सार्वजनिक अनुभाग हैं। पहले खंड में मैं एक कन्स्ट्रक्टर और एक विधि को परिभाषित कर रहा हूं और दूसरे खंड में मैं डेटा सदस्यों की घोषणा कर रहा हूं। उपर्युक्त वर्ग यानी एक सही है। क्या हम वह कर सकते हैं? यदि हां तो इसकी आवश्यकता क्यों है और हमें किस परिस्थितियों में इसका उपयोग करना चाहिए? चूंकि हम पूरी चीज एक सेक्शन में कर सकते हैं तो दो वर्ग क्यों हैं?

Answer 1

एक्सेस क्वालीफायर बस अगले क्वालीफायर तक आने वाले कोड पर लागू होते हैं। ऐसे क्वालीफायरों की संख्या या आदेश पर कोई प्रतिबंध नहीं है।

कक्षा में समान पहुंच योग्यता को दोहराना आवश्यक नहीं है, और ऐसा करने से पाठक को भ्रमित करने की संभावना है। वे कक्षा के लेआउट पर भी असर डाल सकते हैं, क्योंकि एक ही क्वालीफायर के बाद वाले डेटा सदस्यों को घोषित किए जाने वाले क्रम में निर्धारित किया जाना चाहिए, लेकिन क्वालिफायर के बीच ऐसा कोई प्रतिबंध नहीं है।

Answer 2

कक्षा सही है, सार्वजनिक केवल एक पहुंच योग्यता है और अगले क्वालीफायर को देखा जाता है या कक्षा घोषणा के अंत तक लागू होगा। इस वर्ग में कितने एक्सेस क्वालीफायर (सार्वजनिक, निजी, संरक्षित) हो सकते हैं, इस पर कोई सीमा नहीं है। यह क्यों उपयोगी है, यह कक्षा घोषणाओं को जिस तरीके से आप चाहते हैं उसे लिखने में मदद करता है। उदाहरण के लिए, मैं निजी सदस्य सदस्यों (कहें) से पहले घोषित सभी सदस्य कार्य (सार्वजनिक, संरक्षित या निजी) चाहता हूं।

Answer 3

जैसा कि मार्सेलो कहते हैं, आप जितनी बार चाहें सार्वजनिक, निजी और संरक्षित क्वालीफायरों का उपयोग कर सकते हैं। "कब" पूरी तरह से व्यक्तिगत है। इस तरह कुछ लोग:

class AClass 
{ 
public: 
    // all the public stuff 
protected: 
    // all the protected stuff 
private: 
    // all the private stuff 
}; 

लेकिन व्यक्तिगत रूप से (और यह वास्तव में सिर्फ एक निजी पसंद है) मैं यह करना चाहते:

class AClass 
{ 
    // constructors and destructors 
public: 
    // public cons/dest 
protected: 
    // protected cons/dest 
private: 
    // private cons/dest 

    // accessors 
public: 
protected: 
private: 

    // methods 
public: 
protected: 
private: 

    // members 
public: 
protected: 
private: 
}; 

अपनी शैली के साथ आने के लिए स्वतंत्र महसूस, आप जो भी ' साथ आराम करो। ऐसा करने का कोई सही या गलत तरीका नहीं है। बस सुसंगत होने की कोशिश करें।

Answer 4

हां यह सही है हालांकि व्यक्तिगत रूप से मैं कक्षा के शीर्ष पर एक सार्वजनिक अनुभाग रखना पसंद करता हूं, जहां एक नई कक्षा की जांच करते समय प्रोग्रामर पहले दिखते हैं। यह देखना आसान है कि कौन से हिस्सों को सुलभ माना जाना चाहिए और जो नहीं हैं - पूरे वर्ग शीर्षलेख को ब्राउज़ करने के बजाय।

Answer 5

@Marcelo Cantos's answer बताते हैं, इसकी अनुमति है। कोड लिखते समय आपको इससे बचना चाहिए, क्योंकि जब आपका कोड आपके कोड को पढ़ता है तो यह केवल भ्रम की ओर जाता है। वास्तविक जीवन में मैंने इसे देखा है केवल एक ही जगह विभिन्न एमएफसी-जादूगरों द्वारा उत्पन्न कोड में है। जब भी आप विज़ार्ड का उपयोग करके अपनी कक्षा में कुछ चीज जोड़ते हैं, तो यह आपकी कक्षा के अंत में एक अतिरिक्त अनुभाग जोड़ देगा।

Answer 6

मैं आमतौर पर कक्षा की घोषणा की व्यवस्था करने की कोशिश करता हूं ताकि दूसरों के लिए कहा गया वर्ग का उपयोग करना आसान हो।

सामान्य इस प्रकार है: public/protected/private, इस क्रम में, क्योंकि यह पाठकों के लिए जीवन को सरल बनाता है।

• जो लोग कक्षा का उपयोग करते हैं वे protected टैग तक पहुंचने के बाद पढ़ना बंद कर सकते हैं, कुछ भी उनकी चिंता का कोई भी नहीं है।
• कक्षा से प्राप्त होने वाले लोग private टैग तक पहुंचने के बाद पढ़ना बंद कर सकते हैं, कार्यान्वयन विस्तार के बाद कुछ भी।

यह, घोषणाओं के बिंदु पर विधियों के कोड को लिखने के साथ-साथ, पढ़ने में आसान इंटरफ़ेस बनाता है।

वहाँ तथापि चाल के एक जोड़े हैं:

• जब metatemplate प्रोग्रामिंग का उपयोग कर, आप पहली बार बाद में प्रकार की घोषणा करने के तरीकों, ताकि आप public/protected/private
• के 2 श्रृंखला के साथ अंत जब का उपयोग कर की आवश्यकता हो सकती कुंजी idiom (friend के बजाय), आपके पास public अनुभाग है जो वास्तव में उपयोगकर्ताओं के केवल एक छोटे से हिस्से को समर्पित है और सामान्य public अनुभाग के नीचे या protected अनुभाग के बाद सबसे अलग है।

अंत में, गुणों के बीच लेआउट समस्या के बारे में टिप्पणी करने के लिए। Encapsulation का मतलब है कि विशेषता private होना चाहिए। तो, या तो आपके पास struct है और सबकुछ public है या आपके पास कक्षा है और सब कुछ private है, दो साधनों को तोड़ने के लिए मिश्रण करना है, और यह बनाने में एक बग है।