कक्षा

Question

में सूचक बनाम चर मुझे पता है कि अंतर क्या है और वे दोनों कैसे काम करते हैं लेकिन यह प्रश्न कोडिंग शैली के बारे में अधिक है।

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

engine->camera.somevar->x; 
// vs 
engine->camera->somevar->x; 

मैं बीच में डॉट पसंद नहीं है। या निजी चर के साथ:

foo_.getName(); 
// vs 
foo_->gatName(); 

मुझे लगता है कि डॉट "गायब हो जाता है" एक लंबे कोड में। मुझे कुछ मामलों में पढ़ने के लिए -> आसान लगता है।

मेरा प्रश्न यह होगा कि यदि आप कन्स्ट्रक्टर में चर बनाने जा रहे हैं और विनाशक में हटाए गए हैं तो भी आप पॉइंटर्स का उपयोग करते हैं? क्या इस मामले में कोई स्टाइल सलाह है?

पीएस मुझे लगता है कि कुछ मामलों में डॉट बेहतर दिखता है।

Answer 1

सबसे पहले सदस्य चर का पर्दाफाश करने के लिए यह खराब रूप है।

दूसरा आपकी कक्षा शायद कंटेनर पॉइंटर्स कभी नहीं होनी चाहिए।

थोड़ा कोरोलरी: क्लास जिनमें व्यावसायिक तर्क शामिल है, में पॉइंटर्स नहीं होना चाहिए (क्योंकि इसका मतलब है कि उनमें पॉइंटर प्रबंधन कोड भी शामिल है और पॉइंटर प्रबंधन कोड उन वर्गों में छोड़ा जाना चाहिए जिनके पास कोई व्यावसायिक तर्क नहीं है लेकिन विशेष रूप से पॉइंटर्स के प्रबंधन के उद्देश्य से डिजाइन किए गए हैं (स्मार्ट पॉइंटर्स और कंटेनर)

पॉइंटर प्रबंधन कक्षाएं (स्मार्ट पॉइंटर्स/कंटेनर) को एक पॉइंटर प्रबंधित करने के लिए डिज़ाइन किया जाना चाहिए। एक से अधिक का प्रबंधन करना आपके अपेक्षा से कहीं अधिक कठिन है और मुझे अभी तक ऐसी स्थिति नहीं मिली है अतिरिक्त जटिलता का भुगतान किया गया।

अंत में सार्वजनिक सदस्यों को अंतर्निहित कार्यान्वयन का खुलासा नहीं करना चाहिए (आप sho uld गेटर्स/सेटर्स के माध्यम से भी सदस्यों तक पहुंच प्रदान नहीं)। यह कार्यान्वयन के लिए कसकर इंटरफेस बांधता है। इसके बजाय आपके सार्वजनिक इंटरफ़ेस को क्रियाओं का एक सेट प्रदान करना चाहिए जो ऑब्जेक्ट पर किया जा सकता है। यानी verbs हैं।

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

एक निजी परिशिष्ट:

मुझे नफरत है _ तो कम से अपने पहचानकर्ता के अंत में इस पर बनाता है। गायब foo_.getName() मुझे लगता है कि यह एक बहुत बेहतर लग रही है क्योंकि आप को खोजने के रूप में foo.getName()

Answer 2

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

पॉइंटर से संबंधित गलतियों का मौका कम होने के बाद भी इसे संभालना आसान है।

यदि दूसरी तरफ, एम्बेडेड संरचना का संदर्भ कहीं और किया जा सकता है, तो मैं एक अलग संरचना और पॉइंटर्स का उपयोग करना पसंद करता हूं। इस तरह मुझे अपने कोड को दोबारा नहीं करना पड़ेगा अगर यह पता चला कि एम्बेडेड स्ट्रक्चर को अपने माता-पिता से निकाला जाना चाहिए।

संपादित करें:

मुझे लगता है कि इसका मतलब है कि मैं आमतौर पर :-)

संपादित 2 सूचक विकल्प के साथ जाना:

और हाँ, मेरा उत्तर यह सोचते है कि आप वास्तव में चाहते हैं (या) दोनों के बीच चयन करने के लिए यानी कि आप सी-शैली कोड लिखते हैं। वर्ग सदस्यों तक पहुंचने के लिए उचित ऑब्जेक्ट उन्मुख तरीका प्राप्त/सेट फ़ंक्शन के माध्यम से होता है।

मेरी वास्तविक टिप्पणियां या एक पॉइंटर/संदर्भ को संदर्भित करने के बारे में मेरी टिप्पणियां शायद अभी भी मान्य हैं।

Answer 3

आदर्श रूप में, आपको या तो इसका उपयोग नहीं करना चाहिए: आपको गेटर/सेटर विधियों का उपयोग करना चाहिए। प्रदर्शन हिट न्यूनतम है (संकलक शायद इसे दूर कर देगा, वैसे भी)।

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

यदि इनमें से कोई भी आपको परेशान नहीं करता है, तो मैं कहूंगा कि बाकी सब कुछ व्यक्तिगत वरीयता का मामला है।

Answer 4

आप अपनी पसंद नहीं करना चाहिए होगा '->' पढ़ने में आसान :) का उपयोग करते हुए एक सदस्य चर आम तौर पर बेहतर है के रूप में आप आप के साथ गलती नहीं कर सकते हैं सूचक।

यह कहा गया है कि, एक सदस्य परिवर्तनीय बल का उपयोग करके आप अपने कार्यान्वयन का पर्दाफाश कर सकते हैं, इस प्रकार आपको संदर्भों का उपयोग करना होगा। लेकिन फिर आपको अपने कन्स्ट्रक्टर में प्रारंभ करना होगा, जो हमेशा संभव नहीं है ...

एक समाधान std :: auto_ptr या boost :: scoped_ptr ot समान स्मार्ट पॉइंटर का उपयोग करना है। वहां आपको बहुत कम कमियों के साथ समाधान दोनों का लाभ मिलेगा।

my2c

संपादित करें:

कुछ उपयोगी लिंक्स:
Article on std::auto_ptr
boost::scoped_ptr
Pimpl : private implementation