टेम्पलेट प्रकारों का प्रतिनिधित्व करने वाले नामों को एक वर्ण होना चाहिए?

Question

हम these guidelines पर आधारित कुछ सी ++ कोडिंग शैली दिशानिर्देशों को परिभाषित कर रहे हैं। संख्या 8 कहता है "टेम्पलेट प्रकारों का प्रतिनिधित्व करने वाले नाम एक एकल अपरकेस अक्षर होना चाहिए।" स्पष्टीकरण: "सी ++ विकास समुदाय में सामान्य अभ्यास। यह टेम्पलेट नामों को इस्तेमाल किए गए सभी अन्य नामों के सापेक्ष खड़ा करता है।"

क्या यह वास्तव में आम है? मैं मानता हूं कि template<class T> class vector {...} होने के लिए यह बहुत समझ में आता है। लेकिन अगर मेरे पास कई टेम्पलेट तर्क हैं तो क्या होगा? मुझे नहीं लगता कि <class A, class B><class AllocationPolicy, class ThreadingPolicy> से समझना आसान है।

क्या आप सहमत हैं कि अक्सर ऐसे नियम होते हैं जब दिए गए नियम को लागू नहीं किया जाना चाहिए (जिसे 1 के अनुसार अनुमति दी जाती है ...)?

आपके विचारों के लिए धन्यवाद!

Answer 1

मैं वास्तव में उस नामकरण सम्मेलन से सहमत नहीं हूं। मेरे लिए, एक पूर्ण जेनेरिक प्रकार का प्रतिनिधित्व करने वाले टेम्पलेट पैरामीटर एक साधारण अक्षर के रूप में समझते हैं - यह एक प्रकार T है, मुझे वास्तव में परवाह नहीं है। लेकिन अगर इस प्रकार की कोई आवश्यकता है, तो यह नाम उत्पन्न करने के लिए समझ में आता है कि टेम्पलेट तर्क क्या है: template <typename T, typename Allocator> struct container - पहला प्रकार सामान्य है, कोई भी T फिट होगा, लेकिन दूसरा एक आवंटक होगा।

यह काम करता है, जहां आप अपने मानकों को नहीं करना चाहते करने के लिए अलग नहीं a, b के नाम से जाना ... आदेश या दिखने में है, बल्कि प्रलेखन के हिस्से के रूप सार्थक नाम का उत्पादन। साथ ही, यदि स्टाइल गाइड विकसित करना है, तो मैं टेम्पलेट कक्षाओं के मामले में टेम्पलेट तर्कों के स्थानीय टाइपिफ को आवश्यक मानकों (जब भी संभव हो) पर स्थिर आवेषण के साथ एक साथ विचार करने पर विचार करता हूं। यही है, कम से कम अवधारणा उस कार्यक्षमता प्रदान करते हैं।

मैं एसटीएल को लाइब्रेरी का एक अच्छा उदाहरण मानता हूं और आप देख सकते हैं कि उत्पन्न करने वाले टाइप किए गए टाइप कोड को पढ़ने में मदद करते हैं (जी ++ 4 से।2 एसटीएल):

क्लास:

// from <vector> -> <bits/stl_vector.h> 
template<typename _Tp, typename _Alloc = std::allocator<_Tp> > 
class vector : protected _Vector_base<_Tp, _Alloc> 
{ 
    // Concept requirements. 
    typedef typename _Alloc::value_type _Alloc_value_type; // _Alloc contains value_type internal type 
    __glibcxx_class_requires(_Tp, _SGIAssignableConcept) // _Tp is assignable 
[...] 
public: 
    typedef _Tp value_type;     // from here on _Tp is not mentioned 
    typedef typename _Tp_alloc_type::reference reference; // check + typedef 
[...] 
    iterator begin() { 
    // without typedef: 
    // __gnu_cxx::__normal_iterator<pointer, vector_type> begin() { 
[...] 
    reference operator[](size_type __n) 
    // _Tp& operator[](size_type __n) 
[...] 

// from <memory> 
template <typename _Tp> 
class auto_ptr 
{ 
[...] 
    template <typename _Tp1> 
    auto_ptr(auto_ptr<_Tp1>& __a) throw() 

और कार्य:

template <typename _InputIterator, typename _Tp> 
inline _InputIterator find(_InputIterator __first, _InputIterator __last, _Tp value) { 
    // concept requirements 
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) 
    [...] 

उनके नाम के सभी _ और या तो बड़े अक्षर या एक दूसरे _, जो आरक्षित नाम हैं लगाया जाता है कर रहे हैं कार्यान्वयन के लिए, और वे _Tp_T से अधिक पसंद करते हैं, लेकिन अंत में आप देख सकते हैं कि जब भी एक प्रकार जेनेरिक इसे _Tp कहा जाता है , _Tp1 ..., जबकि जब इसकी कुछ विशिष्ट आवश्यकताएं संलग्न होती हैं, तो एक और समझदार नाम चुना जाता है।

, उन दोनों के बीच में एक ठीक लाइन नहीं है std::vector में उदाहरण के लिए के रूप में, वहाँ सामान्य प्रकार पर वास्तविक आवश्यकताओं हैं: _Tp आबंटित होना चाहिए, लेकिन दिन के अंत में, यह एक ज्यादातर सामान्य प्रकार है। इसे _Assignable पर कॉल करना कुछ कंटेनरों में अजीब होगा जहां एक से अधिक आवश्यकताएं हैं।

Answer 2

मुझे लगता है कि यह आपके कितने पैरामीटर पर निर्भर करता है। यदि पैरामीटर एक प्रकार है और यह एकमात्र पैरामीटर है तो यह T क्यों नहीं हो सकता है? हालांकि मैं आपसे सहमत हूं कि कई मानकों के मामले में उनके पास एक ही कारण के लिए सार्थक नाम होना चाहिए क्यों चर के रूप में आमतौर पर सार्थक नाम होना चाहिए।

Answer 3

निश्चित रूप से टेम्पलेट प्रकारों के लिए अभिव्यक्तिपूर्ण नाम क्रम में हैं। यह और भी उपयोगी होगा जब, कुछ दिन, भाषा में अवधारणाएं पेश की जाती हैं (एक दयालुता जिसे वे सी ++ 0x के लिए छोड़ दिए गए थे)। इस बीच, टेम्पलेट पैरामीटर प्रकार का नाम उस दिए गए प्रकार की अपेक्षा का वर्णन करता है, कम से कम अनौपचारिक रूप से (अवधारणाएं उन्हें औपचारिकता प्रदान करती हैं, अपेक्षित प्रकारों और प्रकारों के प्रकार को सूचीबद्ध करती हैं)।

Answer 4

विभिन्न कोडिंग मानक अलग-अलग नामकरण को परिभाषित करेंगे। बस एक उठाओ, और इसके साथ चिपके रहें।

मेरी प्राथमिकताओं में वर्णनात्मक नाम हैं, और कुछ सामान्य प्रकार का नाम टी नहीं है (हालांकि यह कुछ स्थितियों में बुरा नहीं है)।

Answer 5

मुझे लगता है कि एकल-अक्षर नाम (टेम्पलेट्स और अन्यथा) के साथ मुख्य समस्या तब होती है जब आप खोज-और-प्रतिस्थापन करना चाहते हैं। यदि आपके टेक्स्ट एडिटर में सी ++ पार्सर (और अधिकतर नहीं) शामिल नहीं है, तो सिंगल-लेटर नाम बहुत सारे नकली मैचों का कारण बनेंगे जिनके बारे में आपने इरादा नहीं किया था। लंबे/वर्णनात्मक नामों के साथ, ओटीओएच, खोज और प्रतिस्थापन इरादे के रूप में काम करने की अधिक संभावना है।

Answer 6

यदि यह सिर्फ एक प्रकार है, तो मैं एकल-अक्षर पहचानकर्ता (टी, यू आदि) का उपयोग करता हूं। यदि तर्क में एक विशेष अधिक सीमित अर्थ (predicate, आवंटक आदि) है, तो मैं कुछ और वर्णनात्मक उपयोग करता हूं।

हालांकि, एकल अक्षर पहचानकर्ता (टी) वापस आग सकते हैं, मैक्रो (GCC 4.2 Template strange error देखें) के नाम, जो शायद अब पहचानकर्ता के साथ और अधिक संभावना नहीं है के साथ टकराने (अगर वे मैक्रो के रूप में ही ALL_CAPS सम्मेलन का प्रयोग नहीं करते) द्वारा ।