क्या स्टडी :: वेक्टर पुश_बैक के साथ ऑब्जेक्ट्स की प्रतिलिपि बना रहा है?

Question

वालग्रिंड के साथ कई जांच के बाद, मैंने निष्कर्ष निकाला है कि std :: वेक्टर उस ऑब्जेक्ट की एक प्रति बनाता है जिसे आप push_back करना चाहते हैं।

क्या यह वाकई सच है? एक वेक्टर बिना किसी प्रतिलिपि के किसी ऑब्जेक्ट का संदर्भ या पॉइंटर रख सकता है?

धन्यवाद

Answer 1

हां, std::vector<T>::push_back() तर्क की एक प्रति बनाता है और इसे वेक्टर में संग्रहीत करता है। यदि आप अपने वेक्टर में ऑब्जेक्ट्स को पॉइंटर्स स्टोर करना चाहते हैं, तो std::vector<whatever> के बजाय std::vector<whatever*> बनाएं।

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

Answer 2

हाँ, std::vector भंडार प्रतियां। vector को कैसे पता होना चाहिए कि आपकी वस्तुओं के अपेक्षित जीवन-काल क्या हैं?

आप स्थानांतरित या वस्तुओं के स्वामित्व साझा करना चाहते हैं संकेत दिए गए, shared_ptr (TR1Boost या में पाया) की तरह संभवतः स्मार्ट संकेत का उपयोग संसाधन प्रबंधन को कम करने।

Answer 3

std :: वेक्टर हमेशा वेक्टर में जो कुछ भी संग्रहीत किया जा रहा है उसकी एक प्रति बनाता है।

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

Answer 4

न केवल std :: वेक्टर जो कुछ भी आप दबा रहे हैं उसकी एक प्रति बनाते हैं, लेकिन संग्रह की परिभाषा बताती है कि यह ऐसा करेगा, और आप वेक्टर के भीतर सही प्रति semantics के बिना वस्तुओं का उपयोग नहीं कर सकते । तो, उदाहरण के लिए, आप एक वेक्टर में auto_ptr का उपयोग नहीं करते हैं।

Answer 5

यदि आप प्रतियां नहीं चाहते हैं; तो सबसे अच्छा तरीका एक पॉइंटर वेक्टर (या एक और संरचना जो एक ही लक्ष्य के लिए कार्य करता है) का उपयोग करना है। यदि आप प्रतियां चाहते हैं; सीधे push_back() का उपयोग करें। आपके पास कोई अन्य विकल्प नहीं है।

Answer 6

यह पता लगाने के लिए बहुत सारी वाल्ग्रिंड जांच क्यों हुई! बस इसे अपने आप को कुछ सरल कोड के साथ साबित करें उदा।

std::vector<std::string> vec; 

{ 
     std::string obj("hello world"); 
     vec.push_pack(obj); 
} 

std::cout << vec[0] << std::endl; 

हैं "हैलो दुनिया" छपा है, वस्तु चाहिए

Answer 7

प्रासंगिक सी ++ 11 में कॉपी किया गया है सदस्य काम करता है, जो आप उन्हें ले जाकर वस्तुओं के स्वामित्व का हस्तांतरण करने की अनुमति के emplace परिवार है कंटेनर में

उपयोग के मुहावरे की तरह

std::vector<Object> objs; 

Object l_value_obj { /* initialize */ }; 
// use object here... 

objs.emplace_back(std::move(l_value_obj)); 

लगेगा lvalue वस्तु के लिए कदम अन्यथा के रूप में महत्वपूर्ण है कि यह एक संदर्भ या स्थिरांक संदर्भ और चाल निर्माता के नाम से जाना नहीं होगा, क्योंकि भेजा जाता है है।

Answer 8

सी ++ 11 के बाद से, सभी मानक कंटेनर ( std::vector, std::map, आदि) समर्थन चाल अर्थ विज्ञान से

, जिसका अर्थ है कि आप अब मानक कंटेनरों को rvalues ​​गुजरती हैं और एक प्रति बच सकते हैं: वैकल्पिक रूप से आप

// Example object class. 
class object 
{ 
private: 
    int    m_val1; 
    std::string  m_val2; 

public: 
    // Constructor for object class. 
    object(int val1, std::string &&val2) : 
     m_val1(val1), 
     m_val2(std::move(val2)) 
    { 

    } 
}; 

std::vector<object> myList; 

// #1 Copy into the vector. 
object foo1(1, "foo"); 
myList.push_back(foo1); 

// #2 Move into the vector (no copy). 
object foo2(1024, "bar"); 
myList.push_back(std::move(foo2)); 

// #3 Move temporary into vector (no copy). 
myList.push_back(object(453, "baz")); 

// #4 Create instance of object directly inside the vector (no copy, no move). 
myList.emplace_back(453, "qux"); 

ज्यादातर एक ही प्रभाव प्राप्त करने के लिए विभिन्न स्मार्ट संकेत का उपयोग कर सकते हैं:

std::unique_ptr उदाहरण

std::vector<std::unique_ptr<object>> myPtrList; 

// #5a unique_ptr can only ever be moved. 
auto pFoo = std::make_unique<object>(1, "foo"); 
myPtrList.push_back(std::move(pFoo)); 

// #5b unique_ptr can only ever be moved. 
myPtrList.push_back(std::make_unique<object>(1, "foo")); 

std::shared_ptr उदाहरण

std::vector<std::shared_ptr<object>> objectPtrList2; 

// #6 shared_ptr can be used to retain a copy of the pointer and update both the vector 
// value and the local copy simultaneously. 
auto pFooShared = std::make_shared<object>(1, "foo"); 
objectPtrList2.push_back(pFooShared); 
// Pointer to object stored in the vector, but pFooShared is still valid.