बूस्ट के साथ नल पॉइंटर :: shared_ptr?

Question

क्या निम्नलिखित के बराबर है:

std::vector<Foo*> vec; 
vec.push_back(NULL); 

जब boost::shared_ptr के साथ काम? क्या यह निम्नलिखित कोड है?

std::vector< boost::shared_ptr<Foo> > vec; 
vec.push_back(boost::shared_ptr<Foo>()); 

नोट: मैं ऐसी कई वस्तुओं को वापस धक्का दे सकता हूं। क्या मुझे कहीं वैश्विक स्थैतिक nullPtr ऑब्जेक्ट घोषित करना चाहिए? इस तरह उनमें से केवल एक का निर्माण करना होगा:

boost::shared_ptr<Foo> nullPtr; 

Answer 1

हाँ, एक वैश्विक स्थिर नल पॉइंटर घोषणा करते हैं।

Answer 2

आप shared_ptr<Foo> के लिए वैश्विक nullPtr घोषित कर सकते हैं। लेकिन यदि आप वैश्विक नामस्थान को प्रदूषित करते हैं, तो आप shared_ptr<Bar> के लिए वैश्विक nullPtr पर क्या कॉल करेंगे?

आम तौर पर मैं सूचक के वर्ग में स्थैतिक के रूप में शून्य पीआरटी घोषित करता हूं।

#include <boost\shared_ptr.hpp> 

class Foo; // forward decl 
typedef boost::shared_ptr<Foo> FooPtr; 
class Foo 
{ 
public: 
    static FooPtr Null; 
} 
... 
// define static in cpp file 
FooPtr Foo::Null; 
... 
// use Foo Null 
vec.push_back(Foo::Null); 

इस तरह प्रत्येक वर्ग में स्थिर नल होता है।

Answer 3

आपका सुझाव (shared_ptr<T> कोई तर्क के साथ कन्स्ट्रक्टर को कॉल करना) सही है। (मान 0 के साथ कन्स्ट्रक्टर को कॉल करना बराबर है।) मुझे नहीं लगता कि यह vec.push_back() को पूर्व-मौजूदा shared_ptr<T> के साथ कॉल करने से धीमा होगा, क्योंकि दोनों मामलों में निर्माण की आवश्यकता है (या तो प्रत्यक्ष निर्माण या प्रति-निर्माण)।

लेकिन अगर आप चाहते हैं "अच्छे" वाक्य रचना, आप निम्न कोड की कोशिश कर सकते:

class { 
public: 
    template<typename T> 
    operator shared_ptr<T>() { return shared_ptr<T>(); } 
} nullPtr; 

यह एक एकल वैश्विक वस्तु nullPtr है, जो निम्नलिखित प्राकृतिक वाक्य रचना के लिए सक्षम बनाता वाणी:

shared_ptr<int> pi(new int(42)); 
shared_ptr<SomeArbitraryType> psat(new SomeArbitraryType("foonly")); 

... 

pi = nullPtr; 
psat = nullPtr; 

नोट कि यदि आप इसे एकाधिक अनुवाद इकाइयों (स्रोत फ़ाइलों) में उपयोग करते हैं, तो आपको कक्षा को एक नाम देना होगा (उदाहरण के लिए _shared_null_ptr_type), nullPtr ऑब्जेक्ट की परिभाषा को एक अलग .cpp फ़ाइल में ले जाएं, और extern टी में घोषणाएं जोड़ें वह हेडर फ़ाइल जहां वर्ग परिभाषित किया गया है।

Answer 4

खैर, यह कानूनी है:

shared_ptr<Foo> foo; /* don't assign */ 

और इस राज्य में, वह किसी पर पॉइंट नहीं है।तुम भी इस संपत्ति का परीक्षण कर सकते हैं:

if (foo) { 
    // it points to something 
} else { 
    // no it doesn't 
} 

तो ऐसा करने क्यों नहीं:

std::vector < shared_ptr<Foo> > vec; 
vec.push_back (shared_ptr<Foo>); // push an unassigned one 

Answer 5

यहाँ कुछ है जो मुझे लगता है कि थोड़ा सरल है और ठीक काम करता है

(याद typedef है कि आपके दोस्त):

#include <cstdlib> 
#include <vector> 
#include <iostream> 
#include <boost/shared_ptr.hpp> 

typedef boost::shared_ptr< std::vector<char> > CharVecHandle; 

inline CharVecHandle newCharVec(std::vector<char>::size_type size) { 
    return CharVecHandle(new std::vector<char>(size)); 
} 

inline CharVecHandle newCharVec(void) { 
    return CharVecHandle(); 
} 

int main (void) 
{ 
    CharVecHandle cvh = newCharVec(); 

    if (cvh == NULL) 
     std::cout << "It's NULL" << std::endl; 
    else 
     std::cout << "It's not NULL" << std::endl; 

    std::vector<CharVecHandle> cvh_vec; 

    cvh_vec.push_back(newCharVec(64)); 
    cvh_vec.push_back(newCharVec()); 

    // or call the NULL constructor directly 
    cvh_vec.push_back(CharVecHandle()); 

    return EXIT_SUCCESS; 
} 

Answer 6

सी ++ 0x में, आप बससे परिवर्तित कर सकते हैंstd::shared_ptr रहे हैं:

std::vector< boost::shared_ptr<Foo> > vec; 
vec.push_back(nullptr); 

अगले सी ++ मानक से