लंबे कन्स्ट्रक्टर प्रारंभिक सूचियां

Question

आप उनके साथ कैसे व्यवहार करते हैं? मेरे पास कुछ कक्षाएं (आमतौर पर कक्षाएं होती हैं जो आंकड़े इत्यादि होती हैं) कुछ 20+ परिवर्तनीय सदस्यों के साथ, और प्रारंभिक सूचियां बहुत लंबे समय तक समाप्त होती हैं, अगर पृष्ठ मैन्युअल रूप से लपेटती नहीं है तो पेज चौड़ाई से आगे बढ़ती है। क्या आप इस तरह के वर्गों को आजमाते हैं और तोड़ते हैं या आप किसी अन्य तरीके से इसका सामना करते हैं?

यह बहुत साफ नहीं लगती है, लेकिन कभी कभी मैं बहुत की तरह एक दूसरे के ऊपर पर सूची में चर लिखें:

myConstructor(var1, var2, var3, ..., varN) : 
member1(var1), 
member2(var2), 
member3(var3), 
... 
memberN(varN) 

Answer 1

पेज चौड़ाई से विस्तार

खैर , सबसे पहले, आपको शायद पृष्ठ की चौड़ाई पर फैसला करना चाहिए और इसके साथ चिपकना चाहिए। यदि आप चाहें तो अपने संपादक से ऑटो लाइन रैपिंग का उपयोग करें। आपके विंडो आकार से अधिक कोड पढ़ना वाकई मुश्किल है, खासतौर से आपके सहकर्मियों के लिए टर्मिनल से वी या एमएक्स का उपयोग करना। पृष्ठ की चौड़ाई चुनें और इसके साथ चिपके रहें- इसका मतलब यह है कि इन प्रारंभकर्ता सूचियों को एकाधिक (संभवतः कई) लाइनों पर लपेटें।

क्या आप इस तरह की कक्षाओं को आजमाते हैं और तोड़ते हैं?

20 बहुत सारे पैरामीटर हैं, शायद यह टूटा हुआ होने का हकदार है। "भगवान वर्ग" आमतौर पर एक कोड गंध होते हैं और संकेत मिलता है कि एक रिफैक्टरिंग आवश्यक है।

इसका स्वचालित अर्थ यह नहीं है कि आपको चीजों को तोड़ना चाहिए, दिशानिर्देशों के लिए हमेशा अपवाद होते हैं। लेकिन, निश्चित रूप से इसे एक विकल्प के रूप में मानें।

जब आप उन्हें हेडर फ़ाइल में घोषित करते हैं, तो क्या आप उन्हें (या आप) टिप्पणियों के साथ समूहित कर सकते हैं? उदाहरण के लिए: // These next few parameters are for file IO और // These next parameters are for the widget, जो आपको एक अच्छा टेम्पलेट प्रदान करेगा जिसके लिए वस्तुओं को सारणित किया जा रहा है।

कुल मिलाकर वास्तव में बड़ी कक्षाएं बहुत जटिल स्थिति का संकेत देती हैं, और जटिल स्थिति में बग का कारण बनता है। आपको, कार्यों के साथ, उन्हें छोटे और केंद्रित रखना पसंद करते हैं।

{आपका उदाहरण कोड}

मुझे लगता है, काफी पठनीय और "साफ" है, हालांकि यह शायद बहुत लंबी सूची हो जाएगा। जैसा कि मैंने उल्लेख किया है, इसका मुकाबला करने के लिए, मैं इसे छोटे वर्गों में तोड़ने पर विचार करता हूं।

Answer 2

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

Answer 3

प्रारंभ सूचियों बहुत लंबे खत्म, पेज चौड़ाई से विस्तार करता है, तो मैं मैन्युअल रूप से लपेट नहीं है चारों ओर

एक तरीका refactor करने के लिए है: उदाहरण के लिए, बजाय 4 आदिम चर में पास करने का ("टॉप", "बाएं", "चौड़ाई", और "ऊंचाई"), बस एक यौगिक चर ("आयताकार") में गुज़रें।

वैकल्पिक रूप से, बस स्रोत कोड लेआउट के साथ क्या करना:

class Foo 
{ 
    int m_a; 
    int m_b; 
    int m_c; 
public: 
    Foo(
     int a, 
     int b, 
     int c 
     ) 
     : m_a(a) 
     , m_b(b) 
     , m_c(c) 
    { 
    } 
};