किसी सरणी को सही तरीके से कॉपी कैसे करें और SFINAE को इसके साथ क्या करना है

एक कंटेनर से दूसरे में आइटम कॉपी करें? कुछ भी सरल नहीं है, सार्वभौमिक एल्गोरिथ्म 5 लाइनों में फिट बैठता है:

template<class InputIterator, class OutputIterator> OutputIterator copy(InputIterator first, InputIterator last, OutputIterator result) { while(first != last) *result++ = *first++; return result; } 

आपने cplusplus.com से std :: copy के कार्यान्वयन को जान लिया होगा। GNU STL का std कार्यान्वयन क्यों होता है :: प्रतिलिपि 139 लाइनें लेती है? चलिए इसका पता लगाते हैं।
STL सभी सामान्य C ++ प्रोग्राम द्वारा उपयोग की जाने वाली सबसे बुनियादी लाइब्रेरी है। इसलिए, यह एल्गोरिदम का सबसे कुशल कार्यान्वयन प्रदान करना चाहिए। और कई मायनों में प्रभावी:

• निष्पादन की गति
• संकलक-जनित कोड आकार
• मेमोरी की खपत
• संकलन की गति

निष्पादन की गति

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

SFINAE

और यहाँ "प्रतिस्थापन विफलता एक त्रुटि नहीं है" के रूप में जाना जाने वाला सहायता आता है। यदि टेम्पलेट मापदंडों को प्रतिस्थापित करते समय एक गलत अभिव्यक्ति प्राप्त की जाती है, तो यह एक त्रुटि नहीं है। कंपाइलर को पैटर्न को अनदेखा करना चाहिए और खोज जारी रखनी चाहिए। यह महत्वपूर्ण है कि एक टेम्पलेट फ़ंक्शन के मामले में, एक गलत अभिव्यक्ति फ़ंक्शन के शरीर में नहीं दिखाई देनी चाहिए जब एक विशिष्ट टेम्पलेट पहले से ही चुना गया है और खोज जारी रखने के लिए कहीं नहीं है, लेकिन इसके प्रोटोटाइप में। ऐसा करने का सबसे आसान तरीका std :: enable_if का उपयोग करना है।

std :: enable_if

Enable_if अपने आप में बहुत सरल है। यह एक अभिन्न निरंतर और प्रकार से एक टेम्पलेट है। यदि स्थिरांक सत्य है, तो इसमें एक नेस्टेड प्रकार के नाम की घोषणा शामिल है, अन्यथा यह खाली है।

  // Define a nested type if some predicate holds. // Primary template. /// enable_if template<bool, typename _Tp = void> struct enable_if { }; // Partial specialization for true. template<typename _Tp> struct enable_if<true, _Tp> { typedef _Tp type; }; 

टाइप

 std::enable_if<, Type>::type 

परिभाषित किया जाएगा और प्रकार के प्रकार, लेकिन केवल अगर हालत सच है। इसे इस तरह उपयोग करें:

 //      template<class T> std::enable_if<false, T>::type get_t() {return T();} //     template<class T> std::enable_if<true, T>::type get_t() {return T();} 

प्रकार लक्षण

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

एसटीडी का विशेष कार्यान्वयन :: कॉपी

सार्वभौमिक कार्यान्वयन से पहले , इसे जोड़ें:

 template<class T> //  gcc 4.5  std::is_trivially_copiable,      //inline typename std::enable_if<std::is_trivially_copiable<T>::value, T*>::type inline typename std::enable_if<std::is_trivial<T>::value, T*>::type copy(T* first, T* last, T* result) { const ptrdiff_t num = last - first; memmove(result, first, sizeof(T) * num); return result + num; } 

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

 #include <type_traits> #include <cstring> // :     C++11. //  C++03   type_traits (     ) //      . //  is_simple,   memmove,    . //      . template<bool is_simple> struct __do_copy; //    ,   _.    //        . //        ,      //  .         std::copy template<> struct __do_copy<true> { //      //     ,      //  memmove  . template<class InputIterator, class OutputIterator> static inline OutputIterator do_copy(InputIterator first, InputIterator last, OutputIterator result) { typedef typename std::iterator_traits<InputIterator>::value_type ValueType; const std::ptrdiff_t num = last - first; memmove(result, first, sizeof(ValueType) * num); return result + num; } }; template<> struct __do_copy<false> { //   template<class InputIterator, class OutputIterator> static inline OutputIterator do_copy(InputIterator first, InputIterator last, OutputIterator result) { while(first != last) *result++ = *first++; return result; } }; //  trait      //    STL   template<typename, typename> struct are_same : public std::false_type {}; template<typename Tp> struct are_same<Tp, Tp>: public std::true_type {}; template<class InputIterator, class OutputIterator> inline InputIterator copy( InputIterator first, InputIterator last, OutputIterator result) { //  typename    ,  value_type  // , , .   . typedef typename std::iterator_traits<InputIterator>::value_type ValueTypeI; typedef typename std::iterator_traits<OutputIterator>::value_type ValueTypeO; const bool is_simple = ( std::is_trivial<ValueTypeI>::value && std::is_pointer<InputIterator>::value && std::is_pointer<OutputIterator>::value && are_same<ValueTypeI, ValueTypeO>::value); //    return __do_copy<is_simple>::do_copy(first, last, result); } 

इसके अलावा, जीएनयू एसटीएल एक और अनुकूलन का उपयोग करता है: यादृच्छिक अभिगम पुनरावृत्तियों के लिए, एक लूप का उपयोग पुनरावृत्तियों की संख्या की गणना करने के लिए किया जाता है। कंपाइलर ऐसे चक्रों को तैनात कर सकता है, जिससे कार्यक्रम की गति बढ़ जाती है।

उत्पन्न कोड का आकार

कृपया ध्यान दें कि लेख की शुरुआत में टेम्पलेट प्रत्येक नए प्रकार के लिए पूरी तरह से नया कोड उत्पन्न करेगा। दूसरा टेम्प्लेट एक घटाव और एक जोड़ में घटता है, और मेमोव का कार्यान्वयन सभी प्रकार के लिए सामान्य है। यही है, कार्यक्रम को तेज करने के अलावा, इसका आकार कम हो जाता है। इसी तरह की तरकीबें कंटेनरों में इस्तेमाल की जा सकती हैं: वे हिस्से जो संग्रहित प्रकार पर निर्भर नहीं होते हैं उन्हें टेम्पलेट से हटा दिया जाता है और एक सामान्य कार्यान्वयन का उपयोग किया जाता है। उदाहरण के लिए, std :: सूची कार्यान्वयन में, डेटा को संग्रहीत करने वाली टेम्पलेट संरचना में डेटा के अलावा कुछ भी नहीं होता है। पड़ोसियों और उन पर संचालन के लिंक बेस गैर-टेम्पलेट क्लास में लागू किए जाते हैं, जहां से यह विरासत में मिला है।

पुस्तकालय कार्यों का उपयोग करें

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

पुनश्च

ध्यान दें कि std :: copy जानता है कि परिणाम start और finish के बीच नहीं है, लेकिन मेमोव फ़ंक्शन का उपयोग करता है, जो इसे जाँचने के लिए और प्रतिलिपि बनाने की दिशा (शुरुआत से अंत तक या अंत से शुरुआत तक) चुनने के लिए मजबूर होता है। थोड़ा अधिक इष्टतम कार्यान्वयन किया जा सकता है, लेकिन तब एसटीएल डेवलपर्स को प्रत्येक समर्थित आर्किटेक्चर के लिए विशेष रिलीज का समर्थन करना होगा। ग्लिबक डेवलपर्स पहले से ही इस पर अपना समय बर्बाद कर रहे हैं। किसी को भी इस काम की नकल करने की जरूरत नहीं है।