क्या मुझे std :: एक move_ptr को एक चालक कन्स्ट्रक्टर में ले जाना चाहिए?

Question

पर विचार करें:

#include <cstdlib> 
#include <memory> 
#include <string> 
#include <vector> 
#include <algorithm> 
#include <iterator> 
using namespace std; 

class Gizmo 
{ 
public: 
    Gizmo() : foo_(shared_ptr<string>(new string("bar"))) {}; 
    Gizmo(Gizmo&& rhs); // Implemented Below 

private: 
    shared_ptr<string> foo_; 
}; 

/* 
// doesn't use std::move 
Gizmo::Gizmo(Gizmo&& rhs) 
: foo_(rhs.foo_) 
{ 
} 
*/ 


// Does use std::move 
Gizmo::Gizmo(Gizmo&& rhs) 
: foo_(std::move(rhs.foo_)) 
{ 
} 

int main() 
{ 
    typedef vector<Gizmo> Gizmos; 
    Gizmos gizmos; 
    generate_n(back_inserter(gizmos), 10000, []() -> Gizmo 
    { 
     Gizmo ret; 
     return ret; 
    }); 

    random_shuffle(gizmos.begin(), gizmos.end()); 

} 

उपरोक्त कोड में, वहाँ Gizmo::Gizmo(Gizmo&&) के दो संस्करण हैं - एक std::move का उपयोग करता है वास्तव में कदमshared_ptr, और अन्य बस प्रतियां shared_ptr करने के लिए।

दोनों संस्करण सतह पर काम करने लगते हैं। एक अंतर (केवल अंतर जो मैं देख सकता हूं) गैर-move संस्करण में है shared_ptr की संदर्भ संख्या अस्थायी रूप से बढ़ी है, लेकिन केवल संक्षेप में।

मैं सामान्य रूप से आगे बढ़ता हूं और moveshared_ptr, लेकिन केवल मेरे कोड में स्पष्ट और सुसंगत होने के लिए। क्या मैं यहां पर विचार कर रहा हूं? क्या मुझे किसी अन्य तकनीकी कारण के लिए दूसरे पर एक संस्करण पसंद करना चाहिए?

Answer 1

यहां पर मुख्य मुद्दा shared_ptr में अतिरिक्त परमाणु वृद्धि और कमी के कारण छोटे प्रदर्शन अंतर नहीं है, लेकिन ऑपरेशन के अर्थशास्त्र असंगत हैं जब तक आप कोई कदम नहीं उठाते।

हालांकि धारणा यह है कि shared_ptr की संदर्भ संख्या केवल अस्थायी होगी, भाषा में ऐसी कोई गारंटी नहीं है। जिस स्रोत वस्तु से आप आगे बढ़ रहे हैं वह अस्थायी हो सकता है, लेकिन इसमें अधिक जीवनकाल भी हो सकता है। यह एक नामित ऐसा वैरिएबल rvalue-संदर्भ के लिए casted किया गया है हो सकता है (माना std::move(var)) है, जो मामला नहीं shared_ptr से ले जाकर में आप अभी भी बनाए रखने के स्रोत के साथ स्वामित्व साझा है, और अगर गंतव्य shared_ptr में एक छोटा सा दायरा है तो बिंदु वस्तु का जीवनकाल अनिवार्य रूप से बढ़ाया जाएगा।

Answer 2

move का उपयोग बेहतर है: इसे प्रतिलिपि से अधिक कुशल होना चाहिए क्योंकि इसे अतिरिक्त परमाणु वृद्धि और संदर्भ गणना की कमी की आवश्यकता नहीं है।

Answer 3

मैंने जेम्स मैकनेलिस के जवाब को उजागर किया। मैं उनके जवाब के बारे में एक टिप्पणी करना चाहता हूं लेकिन मेरी टिप्पणी टिप्पणी प्रारूप में फिट नहीं होगी। तो मैं इसे यहाँ डाल रहा हूँ।

shared_ptr को प्रतिलिपि बनाने के प्रदर्शन प्रभाव को मापने का एक मजेदार तरीका यह है कि vector<shared_ptr<T>> जैसे कुछ का उपयोग करें या उन्हें पूरा समय कॉपी करें या कॉपी करें। अधिकांश कंपाइलरों के पास भाषा मोड निर्दिष्ट करके सैमसंगिक्स को चालू/बंद करने का एक तरीका होता है (उदा। -dd = C++ 03 या -std = C++ 11)।

यहाँ कोड मैं सिर्फ -O3 में परीक्षण किया है:

#include <chrono> 
#include <memory> 
#include <vector> 
#include <iostream> 

int main() 
{ 
    std::vector<std::shared_ptr<int> > v(10000, std::shared_ptr<int>(new int(3))); 
    typedef std::chrono::high_resolution_clock Clock; 
    typedef Clock::time_point time_point; 
    typedef std::chrono::duration<double, std::micro> us; 
    time_point t0 = Clock::now(); 
    v.erase(v.begin()); 
    time_point t1 = Clock::now(); 
    std::cout << us(t1-t0).count() << "\u00B5s\n"; 
} 

बजना का उपयोग करते हुए/libC++ और -std में = C++ 03 इस बाहर मेरे लिए प्रिंट: करने के लिए

195.368µs 

स्विचिंग - std = C++ 11 मुझे मिलता है:

16.422µs 

आपका माइलेज भिन्न हो सकता है।