C ++ 11 और STL कंटेनरों में शब्दार्थ को स्थानांतरित करें

यह एक छोटा नोट है कि नए सी ++ 11 मानक के आगमन के साथ उनके तत्वों के लिए मानक कंटेनरों की आवश्यकताएं कैसे बदल गई हैं। C ++ 98 में, एक कंटेनर तत्व की आवश्यकता थी, वास्तव में, एक "उचित" कॉपी कंस्ट्रक्टर और असाइनमेंट ऑपरेटर के पास। यदि, उदाहरण के लिए, आपकी कक्षा का एक उद्देश्य संसाधन का मालिक है, तो आमतौर पर नकल असंभव हो जाती है (कम से कम संसाधन की "गहरी" नकल के बिना)। एक उदाहरण के रूप में, आइए CILE 98 में लिखे FILE* आस-पास निम्नलिखित रैपर क्लास देखें:

 class File { FILE* handle; public: File(const char* filename) { if ( !(handle = fopen(filename, "r")) ) throw std::runtime_error("blah blah blah"); } ~File() { if (handle) fclose(handle); } // ... private: File(const File&); //  void operator=(const File&); //  }; 

हम इस वर्ग की वस्तुओं की प्रतिलिपि बनाने और असाइन करने से मना करते हैं, क्योंकि FILE* नकल करने के FILE* कुछ प्लेटफ़ॉर्म-विशिष्ट ट्रिक्स की आवश्यकता होगी, और आमतौर पर इसका बहुत भौतिक अर्थ नहीं होता है।

यदि आप टाइप File की वस्तुओं की पूरी सूची को स्टोर करना चाहते हैं तो क्या File ? दुर्भाग्य से, हम File को एक मानक कंटेनर में उपयोग नहीं कर सकते हैं, अर्थात, ऐसा कोड बस संकलन नहीं करता है:

 std::vector<File> files; files.push_back(File("data.txt")); 

C ++ 98 में इस समस्या का एक विशिष्ट समाधान shared_ptr का shared_ptr :

 std::vector<boost::shared_ptr<File> > files; files.push_back(boost::shared_ptr<File>(new File("data.txt")) ); 

यह समाधान विशेष रूप से आंख को भाता नहीं है, विशेष रूप से इस तथ्य पर विचार करते हुए कि हम गतिशील स्मृति का उपयोग करते हैं जहां ऐसा लगेगा कि इसकी आवश्यकता नहीं है।

यदि हम C ++ 11 के उपयोग की अनुमति देते हैं, तो तस्वीर बहुत बदल जाती है। जब तक आप पूरे कंटेनर को कॉपी करने का इरादा नहीं रखते, तब तक स्टेंड शब्दार्थ के आगमन के साथ, मानक कंटेनरों को सामान्य कॉपी कंस्ट्रक्टर और असाइनमेंट ऑपरेटर की आवश्यकता नहीं होती है। इसके बजाय, विस्थापन के शब्दार्थ पर्याप्त हैं। आइए देखें कि हम C ++ 11 में File वर्ग के साथ उदाहरण को फिर से कैसे लिख सकते हैं:

 class File { FILE* handle; public: File(const char* filename) { if ( !(handle = fopen(filename, "r")) ) throw std::runtime_error("blah blah blah"); } ~File() { if (handle) fclose(handle); } File(File&& that) { handle = that.handle; that.handle = nullptr; } File& operator=(File&& that) { std::swap(handle, that.handle); return *this; } File(const File&) = delete; //  void operator=(const File&) = delete; //  // ... }; 

फिर से हम सामान्य प्रतिलिपि बनाने पर रोक लगाते हैं, लेकिन ऑब्जेक्ट की गति को अनुमति देते हैं। अब यह कोड काम करता है:

 std::vector<File> files; files.push_back(File("data1.txt")); files.push_back(File("data2.txt")); files.erase(files.begin()); 

इसके अलावा, वैरेडिक टेम्प्लेट्स के लिए धन्यवाद, एक नया टेम्प्लेट फ़ंक्शन emplace_back कंटेनरों में दिखाई दिया है, जो आपको इसे कॉपी किए बिना सीधे कंटेनर में ऑब्जेक्ट बनाने की अनुमति देता है:

 std::vector<File> files; files.emplace_back("data1.txt"); //  File("data1.txt")    

मुझे आशा है कि यह नोट स्पष्ट रूप से प्रदर्शित करता है कि चलती वस्तुओं के शब्दार्थ कितना महत्वपूर्ण है। एक नए मानक के लिए संक्रमण में सभी सफलता!