कड़ियों का संक्षिप्त परिचय

एक संक्षिप्त परिचय का अनुवाद रैवल्यू सन्दर्भ, हॉवर्ड ई। हाइनेंट, ब्रेज़न स्ट्रॉस्ट्रुप, ब्रोनक कोज़िकी।



रेवल्यू संदर्भ C ++ भाषा का एक छोटा तकनीकी विस्तार है। वे प्रोग्रामर को तार्किक रूप से अनावश्यक नकल से बचने और सही अग्रेषण प्रदान करने की अनुमति देते हैं। सबसे पहले, वे उच्च-प्रदर्शन परियोजनाओं और पुस्तकालयों में उपयोग के लिए अभिप्रेत हैं।

परिचय

यह दस्तावेज़ नए C ++ भाषा फ़ंक्शन का प्रारंभिक विचार देता है - रैवल्यू संदर्भ। यह एक छोटा ट्यूटोरियल है, पूरा लेख नहीं। अधिक जानकारी के लिए अंत में लिंक की सूची देखें।

कड़ी लिंक

एक rvalue संदर्भ एक मिश्रित प्रकार है, जो C ++ में पारंपरिक संदर्भ के समान है। इन दो प्रकारों के बीच अंतर करने के लिए, हम पारंपरिक C ++ लिंक को एक लैवल्यू लिंक कहेंगे। जब शब्द लिंक दिखाई देता है, तो यह दोनों प्रकार के लिंक पर लागू होता है, और लिंक को लिंक करने के लिए, और लिंक को लिंक करने के लिए।



लैवल्यू के शब्दार्थ के अनुसार, एक निश्चित प्रकार के डालने और उसके बाद एक लिंक बनता है।

A a; A& a_ref1 = a; //  lvalue 
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यदि किसी प्रकार के बाद हम && डालते हैं, तो हमें एक लिंक मिलता है।

 A a; A&& a_ref2 = a; //  rvalue 
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

एक रेवल्यू रेफरेंस लैवल्यू रेफरेंस की तरह ही व्यवहार करता है, सिवाय इसके कि इसे एक अस्थायी ऑब्जेक्ट के साथ जोड़ा जा सकता है, जबकि एक लैवल्यू को एक अस्थायी (गैर-स्थिर) ऑब्जेक्ट के साथ नहीं जोड़ा जा सकता है।

 A& a_ref3 = A(); // ! A&& a_ref4 = A(); // Ok
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

प्रश्न: हमें इसकी आवश्यकता क्यों होगी?!



यह पता चला है कि rvalue लिंक और lvalue लिंक का संयोजन वह है जो आसानी से स्थानांतरित शब्दार्थ को लागू करने के लिए आवश्यक है। सही लिंकिंग को प्राप्त करने के लिए rvalue लिंक का भी उपयोग किया जा सकता है, जो पहले C ++ में एक अनसुलझा मुद्दा था। अधिकांश प्रोग्रामर के लिए, प्रतिद्वंद्विता लिंक आपको अधिक उत्पादक पुस्तकालय बनाने की अनुमति देते हैं।

आंदोलनों के शब्दार्थ (चाल शब्दार्थ)

साइड कॉपी एलिमिनेशन

नकल करना एक महंगा आनंद हो सकता है। उदाहरण के लिए, दो वैक्टर के लिए, जब हम v2 = v1



लिखते हैं, तो आमतौर पर यह एक फ़ंक्शन कॉल, मेमोरी आवंटन और एक लूप का कारण बनता है। यह, ज़ाहिर है, स्वीकार्य है जब हमें वास्तव में वेक्टर की दो प्रतियों की आवश्यकता होती है, लेकिन कई मामलों में ऐसा नहीं होता है: हम अक्सर वेक्टर को एक स्थान से दूसरे स्थान पर कॉपी करते हैं, और फिर पुरानी प्रतिलिपि हटाते हैं। पर विचार करें:

 template <class T> swap(T& a, T& b) { T tmp(a); //       a a = b; //        b b = tmp; //        tmp (.. a) }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

वास्तव में, हमें a



या b



की प्रतियों की आवश्यकता नहीं है, हम सिर्फ उन्हें विनिमय करना चाहते थे। आइए फिर से कोशिश करें:

 template <class T> swap(T& a, T& b) { T tmp(std::move(a)); a = std::move(b); b = std::move(tmp); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यह कॉल move()



पैरामीटर के रूप में पारित ऑब्जेक्ट का मान लौटाता है, लेकिन इस ऑब्जेक्ट की सुरक्षा की गारंटी नहीं देता है। उदाहरण के लिए, यदि आप vector



को move()



में पैरामीटर के रूप में पास करते move()



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



इस मामले में, हमने विशेषज्ञता swap



अनुकूलित swap



। हालाँकि, हम प्रत्येक फ़ंक्शन को डिलीट या ओवरराइट करने से ठीक पहले एक बड़े ऑब्जेक्ट को कॉपी नहीं कर सकते। यह असंवैधानिक होगा।



रिवाल्यू लिंक का मुख्य कार्य हमें पुनर्लेखन कोड या रनटाइम ओवरहेड के बिना स्थानांतरण को लागू करने की अनुमति देना है।

चाल

move



समारोह वास्तव में एक बहुत ही मामूली काम करता है। उसका काम या तो लवल्यू या रिवल्यू पैरामीटर को स्वीकार करना है और उसे कॉपी कंस्ट्रक्टर को कॉल किए बिना उसे वापस करना है:

 template <class T> typename remove_reference<T>::type&& move(T&& a) { return a; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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

ओवल्यूशन / रिवल्यू के लिए ओवरलोड

एक साधारण वर्ग पर विचार करें जो एक संसाधन का मालिक है और प्रतिलिपि शब्दार्थ (कॉपी कंस्ट्रक्टर और असाइनमेंट ऑपरेटर) भी प्रदान करता है। उदाहरण के लिए, clone_ptr



एक पॉइंटर का clone_ptr



हो सकता है और कॉपी करने के लिए उस पर महंगा clone()



विधि clone_ptr



सकता है:

 template <class T> class clone_ptr { private: T* ptr; public: //  explicit clone_ptr(T* p = 0) : ptr(p) {} //  ~clone_ptr() {delete ptr;} //   clone_ptr(const clone_ptr& p) : ptr(p.ptr ? p.ptr->clone() : 0) {} clone_ptr& operator=(const clone_ptr& p) { if (this != &p) { delete ptr; ptr = p.ptr ? p.ptr->clone() : 0; } return *this; } //   clone_ptr(clone_ptr&& p) : ptr(p.ptr) {p.ptr = 0;} clone_ptr& operator=(clone_ptr&& p) { std::swap(ptr, p.ptr); return *this; } //   T& operator*() const {return *ptr;} // ... };
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

चाल शब्दार्थ के अपवाद के साथ, clone_ptr



आज की C ++ पुस्तकों में पाया गया कोड है। उपयोगकर्ता इस तरह clone_ptr



उपयोग कर सकते हैं:

 clone_ptr<base> p1(new derived); // ... clone_ptr<base> p2 = p1; //  p2  p1     
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ध्यान दें कि clone_ptr



लिए एक कॉपी कंस्ट्रक्टर या असाइनमेंट ऑपरेटर को clone_ptr



करना अपेक्षाकृत महंगा ऑपरेशन है। हालाँकि, जब प्रतिलिपि स्रोत का प्रचलन होता है, तो आप संभावित सूचक (चोरी नहीं करेंगे!) को चुराकर संभावित महंगे clone()



ऑपरेशन को कॉल करने से बच सकते हैं। मूव सिमेंटिक्स में, मूव कंस्ट्रक्टर रॉल्यू वैल्यू को निर्मित ऑब्जेक्ट में छोड़ देता है, और असाइनमेंट ऑपरेटर लिंक के रव्यू ऑब्जेक्ट के साथ करंट ऑब्जेक्ट के मानों को स्वैप करता है।



अब, जब कोड rvalue clone_ptr



को कॉपी करने की कोशिश करता है, या अगर वहाँ rvalue कॉपी के स्रोत को पढ़ने की अनुमति है ( std::move



clone_ptr



) का उपयोग करते हुए, तो काम बहुत तेजी से होगा।

 clone_ptr<base> p1(new derived); // ... clone_ptr<base> p2 = std::move(p1); //  p2  ,  p1
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अन्य वर्गों (या तो समावेशन के माध्यम से, या विरासत के माध्यम से) से बने वर्गों के लिए, मूव कंस्ट्रक्शन और मूव असाइनमेंट को आसानी से std::move



फंक्शन का उपयोग करके लागू किया जा सकता है।

 class Derived : public Base { std::vector<int> vec; std::string name; // ... public: // ... //   Derived(Derived&& x) //   rvalue : Base(std::move(x)), vec(std::move(x.vec)), name(std::move(x.name)) { } Derived& operator=(Derived&& x) //   rvalue { Base::operator=(std::move(x)); vec = std::move(x.vec); name = std::move(x.name); return *this; } // ... };
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

प्रत्येक उप-विषय को अब मूव कंस्ट्रक्टर और ऑब्जेक्ट के मूव असाइनमेंट ऑपरेटर में एक प्रतिद्वंद्विता के रूप में माना जाएगा। std::vector



और std::string



, मूव ऑपरेशंस पहले ही लागू किए जा चुके हैं (हमारे clone_ptr



तरह), जो हमें बहुत अधिक महंगी कॉपी ऑपरेशन से बचने की अनुमति देता है।



यह ध्यान देने योग्य है कि पैरामीटर x



पुनर्वास कार्यों में एक अंतराल के रूप x



माना जाता है, इस तथ्य के बावजूद कि इसे एक संदर्भ संदर्भ के रूप में घोषित किया गया है। इसलिए, आपको बेस क्लास में पास होने पर सिर्फ x



बजाय move(x)



उपयोग करना चाहिए। यह कदम शब्दार्थ के लिए एक महत्वपूर्ण सुरक्षा तंत्र है, जिसे एक नामित चर से दोहरे चाल को रोकने के लिए एक आकस्मिक प्रयास को रोकने के लिए डिज़ाइन किया गया है। सभी आंदोलन केवल rvalues ​​से होते हैं या एक स्पष्ट कलाकारों के साथ rvalue ( std::move



Move) का उपयोग करते हैं। यदि चर का नाम है, तो यह एक अंतराल है।



प्रश्न: ऐसे प्रकारों के बारे में जिनके पास संसाधन नहीं हैं? (उदाहरण के लिए, std::complex



?)



इस मामले में, किसी भी कार्य की आवश्यकता नहीं है। प्रतिलिपि निर्माता पहले से ही प्रतिद्वंद्विता के साथ नकल करने के लिए इष्टतम है।

जंगम लेकिन नकल करने योग्य प्रकार नहीं

कुछ प्रकार की प्रतिलिपि के लिए शब्दार्थ लागू नहीं है, लेकिन उन्हें स्थानांतरित किया जा सकता है। उदाहरण के लिए:

• fstream
  
  
  
  
• unique_ptr
  
  
  
  (गैर-साझा और गैर-प्रतिलिपि योग्य स्वामित्व)
• निष्पादन के एक धागे का प्रतिनिधित्व करने वाला प्रकार

यदि ऐसे प्रकारों को चल (हालांकि वे प्रतिलिपि नहीं बने रहते) बनाए जाते हैं, तो उनकी उपयोगिता बहुत बढ़ जाती है। एक चल लेकिन कॉपी की गई वस्तु को फैक्ट्री विधि (पैटर्न) से मूल्य द्वारा वापस नहीं किया जा सकता है:

 ifstream find_and_open_data_file(/* ... */); ... ifstream data_file = find_and_open_data_file(/* ... */); //  !
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इस उदाहरण में, बेस फाइल डिस्क्रिप्टर को एक ऑब्जेक्ट से दूसरे ऑब्जेक्ट में स्थानांतरित किया जाता है, क्योंकि ifstream



स्रोत व्याप्त है। किसी भी समय, केवल एक फ़ाइल विवरणक होता है, और केवल एक ifstream



का मालिक होता है।



एक relocatable लेकिन नकल नहीं प्रकार भी मानक कंटेनरों में रखा जा सकता है। यदि कंटेनर को अपने अंदर के तत्व को "कॉपी" करने की आवश्यकता है (उदाहरण के लिए, vector



लागू करते समय), तो यह कॉपी करने के बजाय इसे स्थानांतरित कर देगा।

 vector<unique_ptr<base>> v1, v2; v1.push_back(unique_ptr<base>(new derived())); // OK,    ... v2 = v1; //   !    . v2 = move(v1); //  .     v2.
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

कई मानक एल्गोरिदम उन्हें कॉपी करने के बजाय एक अनुक्रम के चलते तत्वों से लाभान्वित होते हैं। यह न केवल बेहतर प्रदर्शन प्रदान करता है (जैसा कि std::swap



के मामले में, जिसका क्रियान्वयन ऊपर वर्णित है), लेकिन इन एल्गोरिदम को अवर्णनीय (लेकिन चल) प्रकारों के साथ काम करने की अनुमति देता है। उदाहरण के लिए, निम्न कोड सॉर्ट करता है

 vector<unique_ptr>,   ,     : 
      

        
        
        
      

     
      

        
        
        
      

     struct indirect_less { template <class T> bool operator()(const T& x, const T& y) {return *x < *y;} }; ... std::vector<std::unique_ptr<A>> v; ... std::sort(v.begin(), v.end(), indirect_less());
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

          unique_ptr
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,    swap
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     (       ,    )    /   .  ,       ,            .       ( ,   ),       . 
      

        
        
        
      

     
      

        
        
        
      

       (perfect forwarding) 
      

        
        
        
      

        ,   std::shared_ptr
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
          .          . ,         ,      .      : 
      

        
        
        
      

     
      

        
        
        
      

     template <class T> std::shared_ptr<T> factory() //    { return std::shared_ptr<T>(new T); } template <class T, class A1> std::shared_ptr<T> factory(const A1& a1) //     { return std::shared_ptr<T>(new T(a1)); } //   
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

                . : 
      

        
        
        
      

     
      

        
        
        
      

     std::shared_ptr<A> p = factory<A>(5);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

     :  ,   T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
          ? 
      

        
        
        
      

     
      

        
        
        
      

            ,     factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
             T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     . 
      

        
        
        
      

     
      

        
        
        
      

               factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     : 
      

        
        
        
      

     
      

        
        
        
      

     template <class T, class A1> std::shared_ptr<T> factory(A1& a1) { return std::shared_ptr<T>(new T(a1)); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

       .     const
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
       factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,        (, A1
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     )       T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     .   ,      ,       T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
      .          (, std::bind
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ). 
      

        
        
        
      

     
      

        
        
        
      

        : 
      

        
        
        
      

     
      

        
        
        
      

     std::shared_ptr<A> p = factory<A>(5); // ! A* q = new A(5); // OK
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

           factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,    "5"   factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,     int&
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
            rvalue "5".  ,      ,    . 
      

        
        
        
      

     
      

        
        
        
      

     :        AI
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     &  const AI
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     &? 
      

        
        
        
      

     
      

        
        
        
      

           ,     :          4 .          8  .         16   ..     . 
      

        
        
        
      

     
      

        
        
        
      

     Rvalue        : 
      

        
        
        
      

     
      

        
        
        
      

     template <class T, class A1> std::shared_ptr<T> factory(A1&& a1) { return std::shared_ptr<T>(new T(std::forward<A1>(a1))); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

      rvalue       factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     .   const
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,         factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     . 
      

        
        
        
      

     
      

        
        
        
      

     :    forward
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
        ? 
      

        
        
        
      

     
      

        
        
        
      

       move
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     , forward
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     -     , ,      ,       .     a1
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,     . 
      

        
        
        
      

     
      

        
        
        
      

     , forward
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
      lvalue/rvalue ,    factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     .  factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
       rvalue,    forward
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
       T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
       rvalue.   ,  lvalue   factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,      T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
      lvalue. 
      

        
        
        
      

     
      

        
        
        
      

       forward
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
        : 
      

        
        
        
      

     
      

        
        
        
      

     template <class T> struct identity { typedef T type; }; template <class T> T&& forward(typename identity<T>::type&& a) { return a; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

      
      

        
        
        
      

            ,     .   ,   95%    . 
      

        
        
        
      

     
      

        
        
        
      

           ,    ,  ,   ,     N1377 . 
      

        
        
        
      

     
      

        
        
        
      

             N1385 . 
      

        
        
        
      

     
      

        
        
        
      

        rvalue  (     ),  N1690 . 
      

        
        
        
      

     
      

        
        
        
      

        ,  rvalue ,  N1952 . 
      

        
        
        
      

     
      

        
        
        
      

       rvalue    ,  N2027 . 
      

        
        
        
      

     
      

        
        
        
      

         rvalue    ,   N1771 . 
      

        
        
        
      

     
      

        
        
        
      

           ,    rvalue , : 
      

        
        
        
      

     N1856 N1857 N1858 N1859 N1860 N1861 N1862 
      

        
        
        
      

       rvalue      (this),  N1821 .
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

vector<unique_ptr>, , :



struct indirect_less { template <class T> bool operator()(const T& x, const T& y) {return *x < *y;} }; ... std::vector<std::unique_ptr<A>> v; ... std::sort(v.begin(), v.end(), indirect_less());





unique_ptr



, swap



( , ) / . , , . ( , ), .



(perfect forwarding)

, std::shared_ptr



. . , , . :



template <class T> std::shared_ptr<T> factory() // { return std::shared_ptr<T>(new T); } template <class T, class A1> std::shared_ptr<T> factory(const A1& a1) // { return std::shared_ptr<T>(new T(a1)); } //





. :



std::shared_ptr<A> p = factory<A>(5);





: , T



?



, factory



T



.



factory



:



template <class T, class A1> std::shared_ptr<T> factory(A1& a1) { return std::shared_ptr<T>(new T(a1)); }





. const



factory



, (, A1



) T



. , , T



. (, std::bind



).



:



std::shared_ptr<A> p = factory<A>(5); // ! A* q = new A(5); // OK





factory



, "5" factory



, int&



rvalue "5". , , .



: AI



& const AI



&?



, : 4 . 8 . 16 .. .



Rvalue :



template <class T, class A1> std::shared_ptr<T> factory(A1&& a1) { return std::shared_ptr<T>(new T(std::forward<A1>(a1))); }





rvalue factory



. const



, factory



.



: forward



?



move



, forward



- , , , . a1



, .



, forward



lvalue/rvalue , factory



. factory



rvalue, forward



T



rvalue. , lvalue factory



, T



lvalue.



forward



:



template <class T> struct identity { typedef T type; }; template <class T> T&& forward(typename identity<T>::type&& a) { return a; }







, . , 95% .



, , , , N1377 .



N1385 .



rvalue ( ), N1690 .



, rvalue , N1952 .



rvalue , N2027 .



rvalue , N1771 .



, rvalue , :

N1856 N1857 N1858 N1859 N1860 N1861 N1862

rvalue (this), N1821 .

vector<unique_ptr>, , :



struct indirect_less { template <class T> bool operator()(const T& x, const T& y) {return *x < *y;} }; ... std::vector<std::unique_ptr<A>> v; ... std::sort(v.begin(), v.end(), indirect_less());





unique_ptr



, swap



( , ) / . , , . ( , ), .



(perfect forwarding)

, std::shared_ptr



. . , , . :



template <class T> std::shared_ptr<T> factory() // { return std::shared_ptr<T>(new T); } template <class T, class A1> std::shared_ptr<T> factory(const A1& a1) // { return std::shared_ptr<T>(new T(a1)); } //





. :



std::shared_ptr<A> p = factory<A>(5);





: , T



?



, factory



T



.



factory



:



template <class T, class A1> std::shared_ptr<T> factory(A1& a1) { return std::shared_ptr<T>(new T(a1)); }





. const



factory



, (, A1



) T



. , , T



. (, std::bind



).



:



std::shared_ptr<A> p = factory<A>(5); // ! A* q = new A(5); // OK





factory



, "5" factory



, int&



rvalue "5". , , .



: AI



& const AI



&?



, : 4 . 8 . 16 .. .



Rvalue :



template <class T, class A1> std::shared_ptr<T> factory(A1&& a1) { return std::shared_ptr<T>(new T(std::forward<A1>(a1))); }





rvalue factory



. const



, factory



.



: forward



?



move



, forward



- , , , . a1



, .



, forward



lvalue/rvalue , factory



. factory



rvalue, forward



T



rvalue. , lvalue factory



, T



lvalue.



forward



:



template <class T> struct identity { typedef T type; }; template <class T> T&& forward(typename identity<T>::type&& a) { return a; }







, . , 95% .



, , , , N1377 .



N1385 .



rvalue ( ), N1690 .



, rvalue , N1952 .



rvalue , N2027 .



rvalue , N1771 .



, rvalue , :

N1856 N1857 N1858 N1859 N1860 N1861 N1862

rvalue (this), N1821 .

vector<unique_ptr>, , :



struct indirect_less { template <class T> bool operator()(const T& x, const T& y) {return *x < *y;} }; ... std::vector<std::unique_ptr<A>> v; ... std::sort(v.begin(), v.end(), indirect_less());





unique_ptr



, swap



( , ) / . , , . ( , ), .



(perfect forwarding)

, std::shared_ptr



. . , , . :



template <class T> std::shared_ptr<T> factory() // { return std::shared_ptr<T>(new T); } template <class T, class A1> std::shared_ptr<T> factory(const A1& a1) // { return std::shared_ptr<T>(new T(a1)); } //





. :



std::shared_ptr<A> p = factory<A>(5);





: , T



?



, factory



T



.



factory



:



template <class T, class A1> std::shared_ptr<T> factory(A1& a1) { return std::shared_ptr<T>(new T(a1)); }





. const



factory



, (, A1



) T



. , , T



. (, std::bind



).



:



std::shared_ptr<A> p = factory<A>(5); // ! A* q = new A(5); // OK





factory



, "5" factory



, int&



rvalue "5". , , .



: AI



& const AI



&?



, : 4 . 8 . 16 .. .



Rvalue :



template <class T, class A1> std::shared_ptr<T> factory(A1&& a1) { return std::shared_ptr<T>(new T(std::forward<A1>(a1))); }





rvalue factory



. const



, factory



.



: forward



?



move



, forward



- , , , . a1



, .



, forward



lvalue/rvalue , factory



. factory



rvalue, forward



T



rvalue. , lvalue factory



, T



lvalue.



forward



:



template <class T> struct identity { typedef T type; }; template <class T> T&& forward(typename identity<T>::type&& a) { return a; }







, . , 95% .



, , , , N1377 .



N1385 .



rvalue ( ), N1690 .



, rvalue , N1952 .



rvalue , N2027 .



rvalue , N1771 .



, rvalue , :

N1856 N1857 N1858 N1859 N1860 N1861 N1862

rvalue (this), N1821 .

 vector<unique_ptr>,   ,     : 
      

        
        
        
      

     
      

        
        
        
      

     struct indirect_less { template <class T> bool operator()(const T& x, const T& y) {return *x < *y;} }; ... std::vector<std::unique_ptr<A>> v; ... std::sort(v.begin(), v.end(), indirect_less());
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

          unique_ptr
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,    swap
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     (       ,    )    /   .  ,       ,            .       ( ,   ),       . 
      

        
        
        
      

     
      

        
        
        
      

       (perfect forwarding) 
      

        
        
        
      

        ,   std::shared_ptr
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
          .          . ,         ,      .      : 
      

        
        
        
      

     
      

        
        
        
      

     template <class T> std::shared_ptr<T> factory() //    { return std::shared_ptr<T>(new T); } template <class T, class A1> std::shared_ptr<T> factory(const A1& a1) //     { return std::shared_ptr<T>(new T(a1)); } //   
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

                . : 
      

        
        
        
      

     
      

        
        
        
      

     std::shared_ptr<A> p = factory<A>(5);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

     :  ,   T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
          ? 
      

        
        
        
      

     
      

        
        
        
      

            ,     factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
             T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     . 
      

        
        
        
      

     
      

        
        
        
      

               factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     : 
      

        
        
        
      

     
      

        
        
        
      

     template <class T, class A1> std::shared_ptr<T> factory(A1& a1) { return std::shared_ptr<T>(new T(a1)); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

       .     const
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
       factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,        (, A1
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     )       T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     .   ,      ,       T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
      .          (, std::bind
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ). 
      

        
        
        
      

     
      

        
        
        
      

        : 
      

        
        
        
      

     
      

        
        
        
      

     std::shared_ptr<A> p = factory<A>(5); // ! A* q = new A(5); // OK
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

           factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,    "5"   factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,     int&
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
            rvalue "5".  ,      ,    . 
      

        
        
        
      

     
      

        
        
        
      

     :        AI
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     &  const AI
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     &? 
      

        
        
        
      

     
      

        
        
        
      

           ,     :          4 .          8  .         16   ..     . 
      

        
        
        
      

     
      

        
        
        
      

     Rvalue        : 
      

        
        
        
      

     
      

        
        
        
      

     template <class T, class A1> std::shared_ptr<T> factory(A1&& a1) { return std::shared_ptr<T>(new T(std::forward<A1>(a1))); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

      rvalue       factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     .   const
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,         factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     . 
      

        
        
        
      

     
      

        
        
        
      

     :    forward
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
        ? 
      

        
        
        
      

     
      

        
        
        
      

       move
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     , forward
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     -     , ,      ,       .     a1
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,     . 
      

        
        
        
      

     
      

        
        
        
      

     , forward
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
      lvalue/rvalue ,    factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     .  factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
       rvalue,    forward
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
       T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
       rvalue.   ,  lvalue   factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,      T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
      lvalue. 
      

        
        
        
      

     
      

        
        
        
      

       forward
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
        : 
      

        
        
        
      

     
      

        
        
        
      

     template <class T> struct identity { typedef T type; }; template <class T> T&& forward(typename identity<T>::type&& a) { return a; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

      
      

        
        
        
      

            ,     .   ,   95%    . 
      

        
        
        
      

     
      

        
        
        
      

           ,    ,  ,   ,     N1377 . 
      

        
        
        
      

     
      

        
        
        
      

             N1385 . 
      

        
        
        
      

     
      

        
        
        
      

        rvalue  (     ),  N1690 . 
      

        
        
        
      

     
      

        
        
        
      

        ,  rvalue ,  N1952 . 
      

        
        
        
      

     
      

        
        
        
      

       rvalue    ,  N2027 . 
      

        
        
        
      

     
      

        
        
        
      

         rvalue    ,   N1771 . 
      

        
        
        
      

     
      

        
        
        
      

           ,    rvalue , : 
      

        
        
        
      

     N1856 N1857 N1858 N1859 N1860 N1861 N1862 
      

        
        
        
      

       rvalue      (this),  N1821 .
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

vector<unique_ptr>, , :



struct indirect_less { template <class T> bool operator()(const T& x, const T& y) {return *x < *y;} }; ... std::vector<std::unique_ptr<A>> v; ... std::sort(v.begin(), v.end(), indirect_less());





unique_ptr



, swap



( , ) / . , , . ( , ), .



(perfect forwarding)

, std::shared_ptr



. . , , . :



template <class T> std::shared_ptr<T> factory() // { return std::shared_ptr<T>(new T); } template <class T, class A1> std::shared_ptr<T> factory(const A1& a1) // { return std::shared_ptr<T>(new T(a1)); } //





. :



std::shared_ptr<A> p = factory<A>(5);





: , T



?



, factory



T



.



factory



:



template <class T, class A1> std::shared_ptr<T> factory(A1& a1) { return std::shared_ptr<T>(new T(a1)); }





. const



factory



, (, A1



) T



. , , T



. (, std::bind



).



:



std::shared_ptr<A> p = factory<A>(5); // ! A* q = new A(5); // OK





factory



, "5" factory



, int&



rvalue "5". , , .



: AI



& const AI



&?



, : 4 . 8 . 16 .. .



Rvalue :



template <class T, class A1> std::shared_ptr<T> factory(A1&& a1) { return std::shared_ptr<T>(new T(std::forward<A1>(a1))); }





rvalue factory



. const



, factory



.



: forward



?



move



, forward



- , , , . a1



, .



, forward



lvalue/rvalue , factory



. factory



rvalue, forward



T



rvalue. , lvalue factory



, T



lvalue.



forward



:



template <class T> struct identity { typedef T type; }; template <class T> T&& forward(typename identity<T>::type&& a) { return a; }







, . , 95% .



, , , , N1377 .



N1385 .



rvalue ( ), N1690 .



, rvalue , N1952 .



rvalue , N2027 .



rvalue , N1771 .



, rvalue , :

N1856 N1857 N1858 N1859 N1860 N1861 N1862

rvalue (this), N1821 .

 vector<unique_ptr>,   ,     : 
      

        
        
        
      

     
      

        
        
        
      

     struct indirect_less { template <class T> bool operator()(const T& x, const T& y) {return *x < *y;} }; ... std::vector<std::unique_ptr<A>> v; ... std::sort(v.begin(), v.end(), indirect_less());
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

          unique_ptr
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,    swap
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     (       ,    )    /   .  ,       ,            .       ( ,   ),       . 
      

        
        
        
      

     
      

        
        
        
      

       (perfect forwarding) 
      

        
        
        
      

        ,   std::shared_ptr
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
          .          . ,         ,      .      : 
      

        
        
        
      

     
      

        
        
        
      

     template <class T> std::shared_ptr<T> factory() //    { return std::shared_ptr<T>(new T); } template <class T, class A1> std::shared_ptr<T> factory(const A1& a1) //     { return std::shared_ptr<T>(new T(a1)); } //   
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

                . : 
      

        
        
        
      

     
      

        
        
        
      

     std::shared_ptr<A> p = factory<A>(5); 
      

        
        
        
      

     :  ,   T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
          ? 
      

        
        
        
      

     
      

        
        
        
      

            ,     factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
             T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     . 
      

        
        
        
      

     
      

        
        
        
      

               factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     : 
      

        
        
        
      

     
      

        
        
        
      

     template <class T, class A1> std::shared_ptr<T> factory(A1& a1) { return std::shared_ptr<T>(new T(a1)); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

       .     const
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
       factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,        (, A1
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     )       T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     .   ,      ,       T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
      .          (, std::bind
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ). 
      

        
        
        
      

     
      

        
        
        
      

        : 
      

        
        
        
      

     
      

        
        
        
      

     std::shared_ptr<A> p = factory<A>(5); // ! A* q = new A(5); // OK
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

           factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,    "5"   factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,     int&
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
            rvalue "5".  ,      ,    . 
      

        
        
        
      

     
      

        
        
        
      

     :        AI
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     &  const AI
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     &? 
      

        
        
        
      

     
      

        
        
        
      

           ,     :          4 .          8  .         16   ..     . 
      

        
        
        
      

     
      

        
        
        
      

     Rvalue        : 
      

        
        
        
      

     
      

        
        
        
      

     template <class T, class A1> std::shared_ptr<T> factory(A1&& a1) { return std::shared_ptr<T>(new T(std::forward<A1>(a1))); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

      rvalue       factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     .   const
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,         factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     . 
      

        
        
        
      

     
      

        
        
        
      

     :    forward
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
        ? 
      

        
        
        
      

     
      

        
        
        
      

       move
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     , forward
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     -     , ,      ,       .     a1
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,     . 
      

        
        
        
      

     
      

        
        
        
      

     , forward
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
      lvalue/rvalue ,    factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     .  factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
       rvalue,    forward
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
       T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
       rvalue.   ,  lvalue   factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,      T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
      lvalue. 
      

        
        
        
      

     
      

        
        
        
      

       forward
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
        : 
      

        
        
        
      

     
      

        
        
        
      

     template <class T> struct identity { typedef T type; }; template <class T> T&& forward(typename identity<T>::type&& a) { return a; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

      
      

        
        
        
      

            ,     .   ,   95%    . 
      

        
        
        
      

     
      

        
        
        
      

           ,    ,  ,   ,     N1377 . 
      

        
        
        
      

     
      

        
        
        
      

             N1385 . 
      

        
        
        
      

     
      

        
        
        
      

        rvalue  (     ),  N1690 . 
      

        
        
        
      

     
      

        
        
        
      

        ,  rvalue ,  N1952 . 
      

        
        
        
      

     
      

        
        
        
      

       rvalue    ,  N2027 . 
      

        
        
        
      

     
      

        
        
        
      

         rvalue    ,   N1771 . 
      

        
        
        
      

     
      

        
        
        
      

           ,    rvalue , : 
      

        
        
        
      

     N1856 N1857 N1858 N1859 N1860 N1861 N1862 
      

        
        
        
      

       rvalue      (this),  N1821 .
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

vector<unique_ptr>, , :



struct indirect_less { template <class T> bool operator()(const T& x, const T& y) {return *x < *y;} }; ... std::vector<std::unique_ptr<A>> v; ... std::sort(v.begin(), v.end(), indirect_less());





unique_ptr



, swap



( , ) / . , , . ( , ), .



(perfect forwarding)

, std::shared_ptr



. . , , . :



template <class T> std::shared_ptr<T> factory() // { return std::shared_ptr<T>(new T); } template <class T, class A1> std::shared_ptr<T> factory(const A1& a1) // { return std::shared_ptr<T>(new T(a1)); } //





. :



std::shared_ptr<A> p = factory<A>(5);





: , T



?



, factory



T



.



factory



:



template <class T, class A1> std::shared_ptr<T> factory(A1& a1) { return std::shared_ptr<T>(new T(a1)); }





. const



factory



, (, A1



) T



. , , T



. (, std::bind



).



:



std::shared_ptr<A> p = factory<A>(5); // ! A* q = new A(5); // OK





factory



, "5" factory



, int&



rvalue "5". , , .



: AI



& const AI



&?



, : 4 . 8 . 16 .. .



Rvalue :



template <class T, class A1> std::shared_ptr<T> factory(A1&& a1) { return std::shared_ptr<T>(new T(std::forward<A1>(a1))); }





rvalue factory



. const



, factory



.



: forward



?



move



, forward



- , , , . a1



, .



, forward



lvalue/rvalue , factory



. factory



rvalue, forward



T



rvalue. , lvalue factory



, T



lvalue.



forward



:



template <class T> struct identity { typedef T type; }; template <class T> T&& forward(typename identity<T>::type&& a) { return a; }







, . , 95% .



, , , , N1377 .



N1385 .



rvalue ( ), N1690 .



, rvalue , N1952 .



rvalue , N2027 .



rvalue , N1771 .



, rvalue , :

N1856 N1857 N1858 N1859 N1860 N1861 N1862

rvalue (this), N1821 .

 vector<unique_ptr>,   ,     : 
      

        
        
        
      

     
      

        
        
        
      

     struct indirect_less { template <class T> bool operator()(const T& x, const T& y) {return *x < *y;} }; ... std::vector<std::unique_ptr<A>> v; ... std::sort(v.begin(), v.end(), indirect_less());
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

          unique_ptr
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,    swap
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     (       ,    )    /   .  ,       ,            .       ( ,   ),       . 
      

        
        
        
      

     
      

        
        
        
      

       (perfect forwarding) 
      

        
        
        
      

        ,   std::shared_ptr
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
          .          . ,         ,      .      : 
      

        
        
        
      

     
      

        
        
        
      

     template <class T> std::shared_ptr<T> factory() //    { return std::shared_ptr<T>(new T); } template <class T, class A1> std::shared_ptr<T> factory(const A1& a1) //     { return std::shared_ptr<T>(new T(a1)); } //   
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

                . : 
      

        
        
        
      

     
      

        
        
        
      

     std::shared_ptr<A> p = factory<A>(5);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

     :  ,   T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
          ? 
      

        
        
        
      

     
      

        
        
        
      

            ,     factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
             T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     . 
      

        
        
        
      

     
      

        
        
        
      

               factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     : 
      

        
        
        
      

     
      

        
        
        
      

     template <class T, class A1> std::shared_ptr<T> factory(A1& a1) { return std::shared_ptr<T>(new T(a1)); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

       .     const
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
       factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,        (, A1
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     )       T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     .   ,      ,       T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
      .          (, std::bind
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ). 
      

        
        
        
      

     
      

        
        
        
      

        : 
      

        
        
        
      

     
      

        
        
        
      

     std::shared_ptr<A> p = factory<A>(5); // ! A* q = new A(5); // OK
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

           factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,    "5"   factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,     int&
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
            rvalue "5".  ,      ,    . 
      

        
        
        
      

     
      

        
        
        
      

     :        AI
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     &  const AI
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     &? 
      

        
        
        
      

     
      

        
        
        
      

           ,     :          4 .          8  .         16   ..     . 
      

        
        
        
      

     
      

        
        
        
      

     Rvalue        : 
      

        
        
        
      

     
      

        
        
        
      

     template <class T, class A1> std::shared_ptr<T> factory(A1&& a1) { return std::shared_ptr<T>(new T(std::forward<A1>(a1))); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

      rvalue       factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     .   const
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,         factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     . 
      

        
        
        
      

     
      

        
        
        
      

     :    forward
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
        ? 
      

        
        
        
      

     
      

        
        
        
      

       move
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     , forward
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     -     , ,      ,       .     a1
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,     . 
      

        
        
        
      

     
      

        
        
        
      

     , forward
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
      lvalue/rvalue ,    factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     .  factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
       rvalue,    forward
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
       T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
       rvalue.   ,  lvalue   factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,      T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
      lvalue. 
      

        
        
        
      

     
      

        
        
        
      

       forward
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
        : 
      

        
        
        
      

     
      

        
        
        
      

     template <class T> struct identity { typedef T type; }; template <class T> T&& forward(typename identity<T>::type&& a) { return a; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

      
      

        
        
        
      

            ,     .   ,   95%    . 
      

        
        
        
      

     
      

        
        
        
      

           ,    ,  ,   ,     N1377 . 
      

        
        
        
      

     
      

        
        
        
      

             N1385 . 
      

        
        
        
      

     
      

        
        
        
      

        rvalue  (     ),  N1690 . 
      

        
        
        
      

     
      

        
        
        
      

        ,  rvalue ,  N1952 . 
      

        
        
        
      

     
      

        
        
        
      

       rvalue    ,  N2027 . 
      

        
        
        
      

     
      

        
        
        
      

         rvalue    ,   N1771 . 
      

        
        
        
      

     
      

        
        
        
      

           ,    rvalue , : 
      

        
        
        
      

     N1856 N1857 N1858 N1859 N1860 N1861 N1862 
      

        
        
        
      

       rvalue      (this),  N1821 .
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

vector<unique_ptr>, , :



struct indirect_less { template <class T> bool operator()(const T& x, const T& y) {return *x < *y;} }; ... std::vector<std::unique_ptr<A>> v; ... std::sort(v.begin(), v.end(), indirect_less());





unique_ptr



, swap



( , ) / . , , . ( , ), .



(perfect forwarding)

, std::shared_ptr



. . , , . :



template <class T> std::shared_ptr<T> factory() // { return std::shared_ptr<T>(new T); } template <class T, class A1> std::shared_ptr<T> factory(const A1& a1) // { return std::shared_ptr<T>(new T(a1)); } //





. :



std::shared_ptr<A> p = factory<A>(5);





: , T



?



, factory



T



.



factory



:



template <class T, class A1> std::shared_ptr<T> factory(A1& a1) { return std::shared_ptr<T>(new T(a1)); }





. const



factory



, (, A1



) T



. , , T



. (, std::bind



).



:



std::shared_ptr<A> p = factory<A>(5); // ! A* q = new A(5); // OK





factory



, "5" factory



, int&



rvalue "5". , , .



: AI



& const AI



&?



, : 4 . 8 . 16 .. .



Rvalue :



template <class T, class A1> std::shared_ptr<T> factory(A1&& a1) { return std::shared_ptr<T>(new T(std::forward<A1>(a1))); }





rvalue factory



. const



, factory



.



: forward



?



move



, forward



- , , , . a1



, .



, forward



lvalue/rvalue , factory



. factory



rvalue, forward



T



rvalue. , lvalue factory



, T



lvalue.



forward



:



template <class T> struct identity { typedef T type; }; template <class T> T&& forward(typename identity<T>::type&& a) { return a; }







, . , 95% .



, , , , N1377 .



N1385 .



rvalue ( ), N1690 .



, rvalue , N1952 .



rvalue , N2027 .



rvalue , N1771 .



, rvalue , :

N1856 N1857 N1858 N1859 N1860 N1861 N1862

rvalue (this), N1821 .

 vector<unique_ptr>,   ,     : 
      

        
        
        
      

     
      

        
        
        
      

     struct indirect_less { template <class T> bool operator()(const T& x, const T& y) {return *x < *y;} }; ... std::vector<std::unique_ptr<A>> v; ... std::sort(v.begin(), v.end(), indirect_less());
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

          unique_ptr
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,    swap
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     (       ,    )    /   .  ,       ,            .       ( ,   ),       . 
      

        
        
        
      

     
      

        
        
        
      

       (perfect forwarding) 
      

        
        
        
      

        ,   std::shared_ptr
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
          .          . ,         ,      .      : 
      

        
        
        
      

     
      

        
        
        
      

     template <class T> std::shared_ptr<T> factory() //    { return std::shared_ptr<T>(new T); } template <class T, class A1> std::shared_ptr<T> factory(const A1& a1) //     { return std::shared_ptr<T>(new T(a1)); } //   
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

                . : 
      

        
        
        
      

     
      

        
        
        
      

     std::shared_ptr<A> p = factory<A>(5);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

     :  ,   T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
          ? 
      

        
        
        
      

     
      

        
        
        
      

            ,     factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
             T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     . 
      

        
        
        
      

     
      

        
        
        
      

               factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     : 
      

        
        
        
      

     
      

        
        
        
      

     template <class T, class A1> std::shared_ptr<T> factory(A1& a1) { return std::shared_ptr<T>(new T(a1)); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

       .     const
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
       factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,        (, A1
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     )       T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     .   ,      ,       T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
      .          (, std::bind
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ). 
      

        
        
        
      

     
      

        
        
        
      

        : 
      

        
        
        
      

     
      

        
        
        
      

     std::shared_ptr<A> p = factory<A>(5); // ! A* q = new A(5); // OK
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

           factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,    "5"   factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,     int&
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
            rvalue "5".  ,      ,    . 
      

        
        
        
      

     
      

        
        
        
      

     :        AI
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     &  const AI
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     &? 
      

        
        
        
      

     
      

        
        
        
      

           ,     :          4 .          8  .         16   ..     . 
      

        
        
        
      

     
      

        
        
        
      

     Rvalue        : 
      

        
        
        
      

     
      

        
        
        
      

     template <class T, class A1> std::shared_ptr<T> factory(A1&& a1) { return std::shared_ptr<T>(new T(std::forward<A1>(a1))); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

      rvalue       factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     .   const
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,         factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     . 
      

        
        
        
      

     
      

        
        
        
      

     :    forward
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
        ? 
      

        
        
        
      

     
      

        
        
        
      

       move
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     , forward
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     -     , ,      ,       .     a1
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,     . 
      

        
        
        
      

     
      

        
        
        
      

     , forward
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
      lvalue/rvalue ,    factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     .  factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
       rvalue,    forward
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
       T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
       rvalue.   ,  lvalue   factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,      T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
      lvalue. 
      

        
        
        
      

     
      

        
        
        
      

       forward
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
        : 
      

        
        
        
      

     
      

        
        
        
      

     template <class T> struct identity { typedef T type; }; template <class T> T&& forward(typename identity<T>::type&& a) { return a; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

      
      

        
        
        
      

            ,     .   ,   95%    . 
      

        
        
        
      

     
      

        
        
        
      

           ,    ,  ,   ,     N1377 . 
      

        
        
        
      

     
      

        
        
        
      

             N1385 . 
      

        
        
        
      

     
      

        
        
        
      

        rvalue  (     ),  N1690 . 
      

        
        
        
      

     
      

        
        
        
      

        ,  rvalue ,  N1952 . 
      

        
        
        
      

     
      

        
        
        
      

       rvalue    ,  N2027 . 
      

        
        
        
      

     
      

        
        
        
      

         rvalue    ,   N1771 . 
      

        
        
        
      

     
      

        
        
        
      

           ,    rvalue , : 
      

        
        
        
      

     N1856 N1857 N1858 N1859 N1860 N1861 N1862 
      

        
        
        
      

       rvalue      (this),  N1821 .
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

vector<unique_ptr>, , :



struct indirect_less { template <class T> bool operator()(const T& x, const T& y) {return *x < *y;} }; ... std::vector<std::unique_ptr<A>> v; ... std::sort(v.begin(), v.end(), indirect_less());





unique_ptr



, swap



( , ) / . , , . ( , ), .



(perfect forwarding)

, std::shared_ptr



. . , , . :



template <class T> std::shared_ptr<T> factory() // { return std::shared_ptr<T>(new T); } template <class T, class A1> std::shared_ptr<T> factory(const A1& a1) // { return std::shared_ptr<T>(new T(a1)); } //





. :



std::shared_ptr<A> p = factory<A>(5);





: , T



?



, factory



T



.



factory



:



template <class T, class A1> std::shared_ptr<T> factory(A1& a1) { return std::shared_ptr<T>(new T(a1)); }





. const



factory



, (, A1



) T



. , , T



. (, std::bind



).



:



std::shared_ptr<A> p = factory<A>(5); // ! A* q = new A(5); // OK





factory



, "5" factory



, int&



rvalue "5". , , .



: AI



& const AI



&?



, : 4 . 8 . 16 .. .



Rvalue :



template <class T, class A1> std::shared_ptr<T> factory(A1&& a1) { return std::shared_ptr<T>(new T(std::forward<A1>(a1))); }





rvalue factory



. const



, factory



.



: forward



?



move



, forward



- , , , . a1



, .



, forward



lvalue/rvalue , factory



. factory



rvalue, forward



T



rvalue. , lvalue factory



, T



lvalue.



forward



:



template <class T> struct identity { typedef T type; }; template <class T> T&& forward(typename identity<T>::type&& a) { return a; }







, . , 95% .



, , , , N1377 .



N1385 .



rvalue ( ), N1690 .



, rvalue , N1952 .



rvalue , N2027 .



rvalue , N1771 .



, rvalue , :

N1856 N1857 N1858 N1859 N1860 N1861 N1862

rvalue (this), N1821 .

 vector<unique_ptr>,   ,     : 
      

        
        
        
      

     
      

        
        
        
      

     struct indirect_less { template <class T> bool operator()(const T& x, const T& y) {return *x < *y;} }; ... std::vector<std::unique_ptr<A>> v; ... std::sort(v.begin(), v.end(), indirect_less());
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

          unique_ptr
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,    swap
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     (       ,    )    /   .  ,       ,            .       ( ,   ),       . 
      

        
        
        
      

     
      

        
        
        
      

       (perfect forwarding) 
      

        
        
        
      

        ,   std::shared_ptr
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
          .          . ,         ,      .      : 
      

        
        
        
      

     
      

        
        
        
      

     template <class T> std::shared_ptr<T> factory() //    { return std::shared_ptr<T>(new T); } template <class T, class A1> std::shared_ptr<T> factory(const A1& a1) //     { return std::shared_ptr<T>(new T(a1)); } //   
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

                . : 
      

        
        
        
      

     
      

        
        
        
      

     std::shared_ptr<A> p = factory<A>(5);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

     :  ,   T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
          ? 
      

        
        
        
      

     
      

        
        
        
      

            ,     factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
             T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     . 
      

        
        
        
      

     
      

        
        
        
      

               factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     : 
      

        
        
        
      

     
      

        
        
        
      

     template <class T, class A1> std::shared_ptr<T> factory(A1& a1) { return std::shared_ptr<T>(new T(a1)); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

       .     const
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
       factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,        (, A1
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     )       T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     .   ,      ,       T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
      .          (, std::bind
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ). 
      

        
        
        
      

     
      

        
        
        
      

        : 
      

        
        
        
      

     
      

        
        
        
      

     std::shared_ptr<A> p = factory<A>(5); // ! A* q = new A(5); // OK
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

           factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,    "5"   factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,     int&
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
            rvalue "5".  ,      ,    . 
      

        
        
        
      

     
      

        
        
        
      

     :        AI
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     &  const AI
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     &? 
      

        
        
        
      

     
      

        
        
        
      

           ,     :          4 .          8  .         16   ..     . 
      

        
        
        
      

     
      

        
        
        
      

     Rvalue        : 
      

        
        
        
      

     
      

        
        
        
      

     template <class T, class A1> std::shared_ptr<T> factory(A1&& a1) { return std::shared_ptr<T>(new T(std::forward<A1>(a1))); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

      rvalue       factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     .   const
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,         factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     . 
      

        
        
        
      

     
      

        
        
        
      

     :    forward
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
        ? 
      

        
        
        
      

     
      

        
        
        
      

       move
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     , forward
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     -     , ,      ,       .     a1
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,     . 
      

        
        
        
      

     
      

        
        
        
      

     , forward
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
      lvalue/rvalue ,    factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     .  factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
       rvalue,    forward
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
       T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
       rvalue.   ,  lvalue   factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,      T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
      lvalue. 
      

        
        
        
      

     
      

        
        
        
      

       forward
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
        : 
      

        
        
        
      

     
      

        
        
        
      

     template <class T> struct identity { typedef T type; }; template <class T> T&& forward(typename identity<T>::type&& a) { return a; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

      
      

        
        
        
      

            ,     .   ,   95%    . 
      

        
        
        
      

     
      

        
        
        
      

           ,    ,  ,   ,     N1377 . 
      

        
        
        
      

     
      

        
        
        
      

             N1385 . 
      

        
        
        
      

     
      

        
        
        
      

        rvalue  (     ),  N1690 . 
      

        
        
        
      

     
      

        
        
        
      

        ,  rvalue ,  N1952 . 
      

        
        
        
      

     
      

        
        
        
      

       rvalue    ,  N2027 . 
      

        
        
        
      

     
      

        
        
        
      

         rvalue    ,   N1771 . 
      

        
        
        
      

     
      

        
        
        
      

           ,    rvalue , : 
      

        
        
        
      

     N1856 N1857 N1858 N1859 N1860 N1861 N1862 
      

        
        
        
      

       rvalue      (this),  N1821 .
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

vector<unique_ptr>, , :



struct indirect_less { template <class T> bool operator()(const T& x, const T& y) {return *x < *y;} }; ... std::vector<std::unique_ptr<A>> v; ... std::sort(v.begin(), v.end(), indirect_less());





unique_ptr



, swap



( , ) / . , , . ( , ), .



(perfect forwarding)

, std::shared_ptr



. . , , . :



template <class T> std::shared_ptr<T> factory() // { return std::shared_ptr<T>(new T); } template <class T, class A1> std::shared_ptr<T> factory(const A1& a1) // { return std::shared_ptr<T>(new T(a1)); } //





. :



std::shared_ptr<A> p = factory<A>(5);





: , T



?



, factory



T



.



factory



:



template <class T, class A1> std::shared_ptr<T> factory(A1& a1) { return std::shared_ptr<T>(new T(a1)); }





. const



factory



, (, A1



) T



. , , T



. (, std::bind



).



:



std::shared_ptr<A> p = factory<A>(5); // ! A* q = new A(5); // OK





factory



, "5" factory



, int&



rvalue "5". , , .



: AI



& const AI



&?



, : 4 . 8 . 16 .. .



Rvalue :



template <class T, class A1> std::shared_ptr<T> factory(A1&& a1) { return std::shared_ptr<T>(new T(std::forward<A1>(a1))); }





rvalue factory



. const



, factory



.



: forward



?



move



, forward



- , , , . a1



, .



, forward



lvalue/rvalue , factory



. factory



rvalue, forward



T



rvalue. , lvalue factory



, T



lvalue.



forward



:



template <class T> struct identity { typedef T type; }; template <class T> T&& forward(typename identity<T>::type&& a) { return a; }







, . , 95% .



, , , , N1377 .



N1385 .



rvalue ( ), N1690 .



, rvalue , N1952 .



rvalue , N2027 .



rvalue , N1771 .



, rvalue , :

N1856 N1857 N1858 N1859 N1860 N1861 N1862

rvalue (this), N1821 .

 vector<unique_ptr>,   ,     : 
      

        
        
        
      

     
      

        
        
        
      

     struct indirect_less { template <class T> bool operator()(const T& x, const T& y) {return *x < *y;} }; ... std::vector<std::unique_ptr<A>> v; ... std::sort(v.begin(), v.end(), indirect_less());
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

          unique_ptr
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,    swap
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     (       ,    )    /   .  ,       ,            .       ( ,   ),       . 
      

        
        
        
      

     
      

        
        
        
      

       (perfect forwarding) 
      

        
        
        
      

        ,   std::shared_ptr
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
          .          . ,         ,      .      : 
      

        
        
        
      

     
      

        
        
        
      

     template <class T> std::shared_ptr<T> factory() //    { return std::shared_ptr<T>(new T); } template <class T, class A1> std::shared_ptr<T> factory(const A1& a1) //     { return std::shared_ptr<T>(new T(a1)); } //   
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

                . : 
      

        
        
        
      

     
      

        
        
        
      

     std::shared_ptr<A> p = factory<A>(5);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

     :  ,   T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
          ? 
      

        
        
        
      

     
      

        
        
        
      

            ,     factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
             T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     . 
      

        
        
        
      

     
      

        
        
        
      

               factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     : 
      

        
        
        
      

     
      

        
        
        
      

     template <class T, class A1> std::shared_ptr<T> factory(A1& a1) { return std::shared_ptr<T>(new T(a1)); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

       .     const
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
       factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,        (, A1
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     )       T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     .   ,      ,       T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
      .          (, std::bind
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ). 
      

        
        
        
      

     
      

        
        
        
      

        : 
      

        
        
        
      

     
      

        
        
        
      

     std::shared_ptr<A> p = factory<A>(5); // ! A* q = new A(5); // OK
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

           factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,    "5"   factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,     int&
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
            rvalue "5".  ,      ,    . 
      

        
        
        
      

     
      

        
        
        
      

     :        AI
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     &  const AI
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     &? 
      

        
        
        
      

     
      

        
        
        
      

           ,     :          4 .          8  .         16   ..     . 
      

        
        
        
      

     
      

        
        
        
      

     Rvalue        : 
      

        
        
        
      

     
      

        
        
        
      

     template <class T, class A1> std::shared_ptr<T> factory(A1&& a1) { return std::shared_ptr<T>(new T(std::forward<A1>(a1))); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

      rvalue       factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     .   const
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,         factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     . 
      

        
        
        
      

     
      

        
        
        
      

     :    forward
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
        ? 
      

        
        
        
      

     
      

        
        
        
      

       move
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     , forward
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     -     , ,      ,       .     a1
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,     . 
      

        
        
        
      

     
      

        
        
        
      

     , forward
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
      lvalue/rvalue ,    factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     .  factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
       rvalue,    forward
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
       T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
       rvalue.   ,  lvalue   factory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     ,      T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
      lvalue. 
      

        
        
        
      

     
      

        
        
        
      

       forward
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
        : 
      

        
        
        
      

     
      

        
        
        
      

     template <class T> struct identity { typedef T type; }; template <class T> T&& forward(typename identity<T>::type&& a) { return a; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
      

        
        
        
      

      
      

        
        
        
      

            ,     .   ,   95%    . 
      

        
        
        
      

     
      

        
        
        
      

           ,    ,  ,   ,     N1377 . 
      

        
        
        
      

     
      

        
        
        
      

             N1385 . 
      

        
        
        
      

     
      

        
        
        
      

        rvalue  (     ),  N1690 . 
      

        
        
        
      

     
      

        
        
        
      

        ,  rvalue ,  N1952 . 
      

        
        
        
      

     
      

        
        
        
      

       rvalue    ,  N2027 . 
      

        
        
        
      

     
      

        
        
        
      

         rvalue    ,   N1771 . 
      

        
        
        
      

     
      

        
        
        
      

           ,    rvalue , : 
      

        
        
        
      

     N1856 N1857 N1858 N1859 N1860 N1861 N1862 
      

        
        
        
      

       rvalue      (this),  N1821 .
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

vector<unique_ptr>, , :



struct indirect_less { template <class T> bool operator()(const T& x, const T& y) {return *x < *y;} }; ... std::vector<std::unique_ptr<A>> v; ... std::sort(v.begin(), v.end(), indirect_less());





unique_ptr



, swap



( , ) / . , , . ( , ), .



(perfect forwarding)

, std::shared_ptr



. . , , . :



template <class T> std::shared_ptr<T> factory() // { return std::shared_ptr<T>(new T); } template <class T, class A1> std::shared_ptr<T> factory(const A1& a1) // { return std::shared_ptr<T>(new T(a1)); } //





. :



std::shared_ptr<A> p = factory<A>(5);





: , T



?



, factory



T



.



factory



:



template <class T, class A1> std::shared_ptr<T> factory(A1& a1) { return std::shared_ptr<T>(new T(a1)); }





. const



factory



, (, A1



) T



. , , T



. (, std::bind



).



:



std::shared_ptr<A> p = factory<A>(5); // ! A* q = new A(5); // OK





factory



, "5" factory



, int&



rvalue "5". , , .



: AI



& const AI



&?



, : 4 . 8 . 16 .. .



Rvalue :



template <class T, class A1> std::shared_ptr<T> factory(A1&& a1) { return std::shared_ptr<T>(new T(std::forward<A1>(a1))); }





rvalue factory



. const



, factory



.



: forward



?



move



, forward



- , , , . a1



, .



, forward



lvalue/rvalue , factory



. factory



rvalue, forward



T



rvalue. , lvalue factory



, T



lvalue.



forward



:



template <class T> struct identity { typedef T type; }; template <class T> T&& forward(typename identity<T>::type&& a) { return a; }







, . , 95% .



, , , , N1377 .



N1385 .



rvalue ( ), N1690 .



, rvalue , N1952 .



rvalue , N2027 .



rvalue , N1771 .



, rvalue , :

N1856 N1857 N1858 N1859 N1860 N1861 N1862

rvalue (this), N1821 .

vector<unique_ptr>, , :



struct indirect_less { template <class T> bool operator()(const T& x, const T& y) {return *x < *y;} }; ... std::vector<std::unique_ptr<A>> v; ... std::sort(v.begin(), v.end(), indirect_less());





unique_ptr



, swap



( , ) / . , , . ( , ), .



(perfect forwarding)

, std::shared_ptr



. . , , . :



template <class T> std::shared_ptr<T> factory() // { return std::shared_ptr<T>(new T); } template <class T, class A1> std::shared_ptr<T> factory(const A1& a1) // { return std::shared_ptr<T>(new T(a1)); } //





. :



std::shared_ptr<A> p = factory<A>(5);





: , T



?



, factory



T



.



factory



:



template <class T, class A1> std::shared_ptr<T> factory(A1& a1) { return std::shared_ptr<T>(new T(a1)); }





. const



factory



, (, A1



) T



. , , T



. (, std::bind



).



:



std::shared_ptr<A> p = factory<A>(5); // ! A* q = new A(5); // OK





factory



, "5" factory



, int&



rvalue "5". , , .



: AI



& const AI



&?



, : 4 . 8 . 16 .. .



Rvalue :



template <class T, class A1> std::shared_ptr<T> factory(A1&& a1) { return std::shared_ptr<T>(new T(std::forward<A1>(a1))); }





rvalue factory



. const



, factory



.



: forward



?



move



, forward



- , , , . a1



, .



, forward



lvalue/rvalue , factory



. factory



rvalue, forward



T



rvalue. , lvalue factory



, T



lvalue.



forward



:



template <class T> struct identity { typedef T type; }; template <class T> T&& forward(typename identity<T>::type&& a) { return a; }







, . , 95% .



, , , , N1377 .



N1385 .



rvalue ( ), N1690 .



, rvalue , N1952 .



rvalue , N2027 .



rvalue , N1771 .



, rvalue , :

N1856 N1857 N1858 N1859 N1860 N1861 N1862

rvalue (this), N1821 .

vector<unique_ptr>, , :



struct indirect_less { template <class T> bool operator()(const T& x, const T& y) {return *x < *y;} }; ... std::vector<std::unique_ptr<A>> v; ... std::sort(v.begin(), v.end(), indirect_less());





unique_ptr



, swap



( , ) / . , , . ( , ), .



(perfect forwarding)

, std::shared_ptr



. . , , . :



template <class T> std::shared_ptr<T> factory() // { return std::shared_ptr<T>(new T); } template <class T, class A1> std::shared_ptr<T> factory(const A1& a1) // { return std::shared_ptr<T>(new T(a1)); } //





. :



std::shared_ptr<A> p = factory<A>(5);





: , T



?



, factory



T



.



factory



:



template <class T, class A1> std::shared_ptr<T> factory(A1& a1) { return std::shared_ptr<T>(new T(a1)); }





. const



factory



, (, A1



) T



. , , T



. (, std::bind



).



:



std::shared_ptr<A> p = factory<A>(5); // ! A* q = new A(5); // OK





factory



, "5" factory



, int&



rvalue "5". , , .



: AI



& const AI



&?



, : 4 . 8 . 16 .. .



Rvalue :



template <class T, class A1> std::shared_ptr<T> factory(A1&& a1) { return std::shared_ptr<T>(new T(std::forward<A1>(a1))); }





rvalue factory



. const



, factory



.



: forward



?



move



, forward



- , , , . a1



, .



, forward



lvalue/rvalue , factory



. factory



rvalue, forward



T



rvalue. , lvalue factory



, T



lvalue.



forward



:



template <class T> struct identity { typedef T type; }; template <class T> T&& forward(typename identity<T>::type&& a) { return a; }







, . , 95% .



, , , , N1377 .



N1385 .



rvalue ( ), N1690 .



, rvalue , N1952 .



rvalue , N2027 .



rvalue , N1771 .



, rvalue , :

N1856 N1857 N1858 N1859 N1860 N1861 N1862

rvalue (this), N1821 .

• vector<unique_ptr>, , :



struct indirect_less { template <class T> bool operator()(const T& x, const T& y) {return *x < *y;} }; ... std::vector<std::unique_ptr<A>> v; ... std::sort(v.begin(), v.end(), indirect_less());





unique_ptr



, swap



( , ) / . , , . ( , ), .



(perfect forwarding)

, std::shared_ptr



. . , , . :



template <class T> std::shared_ptr<T> factory() // { return std::shared_ptr<T>(new T); } template <class T, class A1> std::shared_ptr<T> factory(const A1& a1) // { return std::shared_ptr<T>(new T(a1)); } //





. :



std::shared_ptr<A> p = factory<A>(5);





: , T



?



, factory



T



.



factory



:



template <class T, class A1> std::shared_ptr<T> factory(A1& a1) { return std::shared_ptr<T>(new T(a1)); }





. const



factory



, (, A1



) T



. , , T



. (, std::bind



).



:



std::shared_ptr<A> p = factory<A>(5); // ! A* q = new A(5); // OK





factory



, "5" factory



, int&



rvalue "5". , , .



: AI



& const AI



&?



, : 4 . 8 . 16 .. .



Rvalue :



template <class T, class A1> std::shared_ptr<T> factory(A1&& a1) { return std::shared_ptr<T>(new T(std::forward<A1>(a1))); }





rvalue factory



. const



, factory



.



: forward



?



move



, forward



- , , , . a1



, .



, forward



lvalue/rvalue , factory



. factory



rvalue, forward



T



rvalue. , lvalue factory



, T



lvalue.



forward



:



template <class T> struct identity { typedef T type; }; template <class T> T&& forward(typename identity<T>::type&& a) { return a; }







, . , 95% .



, , , , N1377 .



N1385 .



rvalue ( ), N1690 .



, rvalue , N1952 .



rvalue , N2027 .



rvalue , N1771 .



, rvalue , :

N1856 N1857 N1858 N1859 N1860 N1861 N1862

rvalue (this), N1821 .
  
  
  
  
• vector<unique_ptr>, , :



struct indirect_less { template <class T> bool operator()(const T& x, const T& y) {return *x < *y;} }; ... std::vector<std::unique_ptr<A>> v; ... std::sort(v.begin(), v.end(), indirect_less());





unique_ptr



, swap



( , ) / . , , . ( , ), .



(perfect forwarding)

, std::shared_ptr



. . , , . :



template <class T> std::shared_ptr<T> factory() // { return std::shared_ptr<T>(new T); } template <class T, class A1> std::shared_ptr<T> factory(const A1& a1) // { return std::shared_ptr<T>(new T(a1)); } //





. :



std::shared_ptr<A> p = factory<A>(5);





: , T



?



, factory



T



.



factory



:



template <class T, class A1> std::shared_ptr<T> factory(A1& a1) { return std::shared_ptr<T>(new T(a1)); }





. const



factory



, (, A1



) T



. , , T



. (, std::bind



).



:



std::shared_ptr<A> p = factory<A>(5); // ! A* q = new A(5); // OK





factory



, "5" factory



, int&



rvalue "5". , , .



: AI



& const AI



&?



, : 4 . 8 . 16 .. .



Rvalue :



template <class T, class A1> std::shared_ptr<T> factory(A1&& a1) { return std::shared_ptr<T>(new T(std::forward<A1>(a1))); }





rvalue factory



. const



, factory



.



: forward



?



move



, forward



- , , , . a1



, .



, forward



lvalue/rvalue , factory



. factory



rvalue, forward



T



rvalue. , lvalue factory



, T



lvalue.



forward



:



template <class T> struct identity { typedef T type; }; template <class T> T&& forward(typename identity<T>::type&& a) { return a; }







, . , 95% .



, , , , N1377 .



N1385 .



rvalue ( ), N1690 .



, rvalue , N1952 .



rvalue , N2027 .



rvalue , N1771 .



, rvalue , :

N1856 N1857 N1858 N1859 N1860 N1861 N1862

rvalue (this), N1821 .
  
  
  
  
• vector<unique_ptr>, , :



struct indirect_less { template <class T> bool operator()(const T& x, const T& y) {return *x < *y;} }; ... std::vector<std::unique_ptr<A>> v; ... std::sort(v.begin(), v.end(), indirect_less());





unique_ptr



, swap



( , ) / . , , . ( , ), .



(perfect forwarding)

, std::shared_ptr



. . , , . :



template <class T> std::shared_ptr<T> factory() // { return std::shared_ptr<T>(new T); } template <class T, class A1> std::shared_ptr<T> factory(const A1& a1) // { return std::shared_ptr<T>(new T(a1)); } //





. :



std::shared_ptr<A> p = factory<A>(5);





: , T



?



, factory



T



.



factory



:



template <class T, class A1> std::shared_ptr<T> factory(A1& a1) { return std::shared_ptr<T>(new T(a1)); }





. const



factory



, (, A1



) T



. , , T



. (, std::bind



).



:



std::shared_ptr<A> p = factory<A>(5); // ! A* q = new A(5); // OK





factory



, "5" factory



, int&



rvalue "5". , , .



: AI



& const AI



&?



, : 4 . 8 . 16 .. .



Rvalue :



template <class T, class A1> std::shared_ptr<T> factory(A1&& a1) { return std::shared_ptr<T>(new T(std::forward<A1>(a1))); }





rvalue factory



. const



, factory



.



: forward



?



move



, forward



- , , , . a1



, .



, forward



lvalue/rvalue , factory



. factory



rvalue, forward



T



rvalue. , lvalue factory



, T



lvalue.



forward



:



template <class T> struct identity { typedef T type; }; template <class T> T&& forward(typename identity<T>::type&& a) { return a; }







, . , 95% .



, , , , N1377 .



N1385 .



rvalue ( ), N1690 .



, rvalue , N1952 .



rvalue , N2027 .



rvalue , N1771 .



, rvalue , :

N1856 N1857 N1858 N1859 N1860 N1861 N1862

rvalue (this), N1821 .
  
  
  
  
• vector<unique_ptr>, , :



struct indirect_less { template <class T> bool operator()(const T& x, const T& y) {return *x < *y;} }; ... std::vector<std::unique_ptr<A>> v; ... std::sort(v.begin(), v.end(), indirect_less());





unique_ptr



, swap



( , ) / . , , . ( , ), .



(perfect forwarding)

, std::shared_ptr



. . , , . :



template <class T> std::shared_ptr<T> factory() // { return std::shared_ptr<T>(new T); } template <class T, class A1> std::shared_ptr<T> factory(const A1& a1) // { return std::shared_ptr<T>(new T(a1)); } //





. :



std::shared_ptr<A> p = factory<A>(5);





: , T



?



, factory



T



.



factory



:



template <class T, class A1> std::shared_ptr<T> factory(A1& a1) { return std::shared_ptr<T>(new T(a1)); }





. const



factory



, (, A1



) T



. , , T



. (, std::bind



).



:



std::shared_ptr<A> p = factory<A>(5); // ! A* q = new A(5); // OK





factory



, "5" factory



, int&



rvalue "5". , , .



: AI



& const AI



&?



, : 4 . 8 . 16 .. .



Rvalue :



template <class T, class A1> std::shared_ptr<T> factory(A1&& a1) { return std::shared_ptr<T>(new T(std::forward<A1>(a1))); }





rvalue factory



. const



, factory



.



: forward



?



move



, forward



- , , , . a1



, .



, forward



lvalue/rvalue , factory



. factory



rvalue, forward



T



rvalue. , lvalue factory



, T



lvalue.



forward



:



template <class T> struct identity { typedef T type; }; template <class T> T&& forward(typename identity<T>::type&& a) { return a; }







, . , 95% .



, , , , N1377 .



N1385 .



rvalue ( ), N1690 .



, rvalue , N1952 .



rvalue , N2027 .



rvalue , N1771 .



, rvalue , :

N1856 N1857 N1858 N1859 N1860 N1861 N1862

rvalue (this), N1821 .
  
  
  
  
• vector<unique_ptr>, , :



struct indirect_less { template <class T> bool operator()(const T& x, const T& y) {return *x < *y;} }; ... std::vector<std::unique_ptr<A>> v; ... std::sort(v.begin(), v.end(), indirect_less());





unique_ptr



, swap



( , ) / . , , . ( , ), .



(perfect forwarding)

, std::shared_ptr



. . , , . :



template <class T> std::shared_ptr<T> factory() // { return std::shared_ptr<T>(new T); } template <class T, class A1> std::shared_ptr<T> factory(const A1& a1) // { return std::shared_ptr<T>(new T(a1)); } //





. :



std::shared_ptr<A> p = factory<A>(5);





: , T



?



, factory



T



.



factory



:



template <class T, class A1> std::shared_ptr<T> factory(A1& a1) { return std::shared_ptr<T>(new T(a1)); }





. const



factory



, (, A1



) T



. , , T



. (, std::bind



).



:



std::shared_ptr<A> p = factory<A>(5); // ! A* q = new A(5); // OK





factory



, "5" factory



, int&



rvalue "5". , , .



: AI



& const AI



&?



, : 4 . 8 . 16 .. .



Rvalue :



template <class T, class A1> std::shared_ptr<T> factory(A1&& a1) { return std::shared_ptr<T>(new T(std::forward<A1>(a1))); }





rvalue factory



. const



, factory



.



: forward



?



move



, forward



- , , , . a1



, .



, forward



lvalue/rvalue , factory



. factory



rvalue, forward



T



rvalue. , lvalue factory



, T



lvalue.



forward



:



template <class T> struct identity { typedef T type; }; template <class T> T&& forward(typename identity<T>::type&& a) { return a; }







, . , 95% .



, , , , N1377 .



N1385 .



rvalue ( ), N1690 .



, rvalue , N1952 .



rvalue , N2027 .



rvalue , N1771 .



, rvalue , :

N1856 N1857 N1858 N1859 N1860 N1861 N1862

rvalue (this), N1821 .
  
  
  
  
• vector<unique_ptr>, , :



struct indirect_less { template <class T> bool operator()(const T& x, const T& y) {return *x < *y;} }; ... std::vector<std::unique_ptr<A>> v; ... std::sort(v.begin(), v.end(), indirect_less());





unique_ptr



, swap



( , ) / . , , . ( , ), .



(perfect forwarding)

, std::shared_ptr



. . , , . :



template <class T> std::shared_ptr<T> factory() // { return std::shared_ptr<T>(new T); } template <class T, class A1> std::shared_ptr<T> factory(const A1& a1) // { return std::shared_ptr<T>(new T(a1)); } //





. :



std::shared_ptr<A> p = factory<A>(5);





: , T



?



, factory



T



.



factory



:



template <class T, class A1> std::shared_ptr<T> factory(A1& a1) { return std::shared_ptr<T>(new T(a1)); }





. const



factory



, (, A1



) T



. , , T



. (, std::bind



).



:



std::shared_ptr<A> p = factory<A>(5); // ! A* q = new A(5); // OK





factory



, "5" factory



, int&



rvalue "5". , , .



: AI



& const AI



&?



, : 4 . 8 . 16 .. .



Rvalue :



template <class T, class A1> std::shared_ptr<T> factory(A1&& a1) { return std::shared_ptr<T>(new T(std::forward<A1>(a1))); }





rvalue factory



. const



, factory



.



: forward



?



move



, forward



- , , , . a1



, .



, forward



lvalue/rvalue , factory



. factory



rvalue, forward



T



rvalue. , lvalue factory



, T



lvalue.



forward



:



template <class T> struct identity { typedef T type; }; template <class T> T&& forward(typename identity<T>::type&& a) { return a; }







, . , 95% .



, , , , N1377 .



N1385 .



rvalue ( ), N1690 .



, rvalue , N1952 .



rvalue , N2027 .



rvalue , N1771 .



, rvalue , :

N1856 N1857 N1858 N1859 N1860 N1861 N1862

rvalue (this), N1821 .
  
  
  
  
• vector<unique_ptr>, , :



struct indirect_less { template <class T> bool operator()(const T& x, const T& y) {return *x < *y;} }; ... std::vector<std::unique_ptr<A>> v; ... std::sort(v.begin(), v.end(), indirect_less());





unique_ptr



, swap



( , ) / . , , . ( , ), .



(perfect forwarding)

, std::shared_ptr



. . , , . :



template <class T> std::shared_ptr<T> factory() // { return std::shared_ptr<T>(new T); } template <class T, class A1> std::shared_ptr<T> factory(const A1& a1) // { return std::shared_ptr<T>(new T(a1)); } //





. :



std::shared_ptr<A> p = factory<A>(5);





: , T



?



, factory



T



.



factory



:



template <class T, class A1> std::shared_ptr<T> factory(A1& a1) { return std::shared_ptr<T>(new T(a1)); }





. const



factory



, (, A1



) T



. , , T



. (, std::bind



).



:



std::shared_ptr<A> p = factory<A>(5); // ! A* q = new A(5); // OK





factory



, "5" factory



, int&



rvalue "5". , , .



: AI



& const AI



&?



, : 4 . 8 . 16 .. .



Rvalue :



template <class T, class A1> std::shared_ptr<T> factory(A1&& a1) { return std::shared_ptr<T>(new T(std::forward<A1>(a1))); }





rvalue factory



. const



, factory



.



: forward



?



move



, forward



- , , , . a1



, .



, forward



lvalue/rvalue , factory



. factory



rvalue, forward



T



rvalue. , lvalue factory



, T



lvalue.



forward



:



template <class T> struct identity { typedef T type; }; template <class T> T&& forward(typename identity<T>::type&& a) { return a; }







, . , 95% .



, , , , N1377 .



N1385 .



rvalue ( ), N1690 .



, rvalue , N1952 .



rvalue , N2027 .



rvalue , N1771 .



, rvalue , :

N1856 N1857 N1858 N1859 N1860 N1861 N1862

rvalue (this), N1821 .
  
  
  
  

vector<unique_ptr>, , :



struct indirect_less { template <class T> bool operator()(const T& x, const T& y) {return *x < *y;} }; ... std::vector<std::unique_ptr<A>> v; ... std::sort(v.begin(), v.end(), indirect_less());





unique_ptr



, swap



( , ) / . , , . ( , ), .



(perfect forwarding)

, std::shared_ptr



. . , , . :



template <class T> std::shared_ptr<T> factory() // { return std::shared_ptr<T>(new T); } template <class T, class A1> std::shared_ptr<T> factory(const A1& a1) // { return std::shared_ptr<T>(new T(a1)); } //





. :



std::shared_ptr<A> p = factory<A>(5);





: , T



?



, factory



T



.



factory



:



template <class T, class A1> std::shared_ptr<T> factory(A1& a1) { return std::shared_ptr<T>(new T(a1)); }





. const



factory



, (, A1



) T



. , , T



. (, std::bind



).



:



std::shared_ptr<A> p = factory<A>(5); // ! A* q = new A(5); // OK





factory



, "5" factory



, int&



rvalue "5". , , .



: AI



& const AI



&?



, : 4 . 8 . 16 .. .



Rvalue :



template <class T, class A1> std::shared_ptr<T> factory(A1&& a1) { return std::shared_ptr<T>(new T(std::forward<A1>(a1))); }





rvalue factory



. const



, factory



.



: forward



?



move



, forward



- , , , . a1



, .



, forward



lvalue/rvalue , factory



. factory



rvalue, forward



T



rvalue. , lvalue factory



, T



lvalue.



forward



:



template <class T> struct identity { typedef T type; }; template <class T> T&& forward(typename identity<T>::type&& a) { return a; }







, . , 95% .



, , , , N1377 .



N1385 .



rvalue ( ), N1690 .



, rvalue , N1952 .



rvalue , N2027 .



rvalue , N1771 .



, rvalue , :

N1856 N1857 N1858 N1859 N1860 N1861 N1862

rvalue (this), N1821 .