किसी अन्य मान के साथ एक नई वस्तु को लौटाना

Question

मैं दो मान वापस करना चाहता हूं, जिनमें से एक एक नई वस्तु है। मैं std::pair का उपयोग कर ऐसा कर सकते हैं:

class A { 
//... 
}; 

std::pair<A*, int> getA() 
{ 
    A* a = new A; 
    //... 
} 

कोड अपवाद-सुरक्षित बनाने के लिए, मुझे क्या करना चाहते हैं:

std::pair<std::auto_ptr<A>, int> getA() 
{ 
    std::auto_ptr<A> a(new A); 
    //... 
} 

लेकिन इस संकलन नहीं होगा के रूप में auto_ptr को संशोधित किए बिना कॉपी नहीं किया जा सकता है auto_ptr कॉपी किया जा रहा है। ठीक है, इसका मतलब है auto_ptr अन्य प्रकारों (एक और तरीके से) की तरह अच्छी तरह से लिखता नहीं है। इस मामले में एक नई वस्तु वापस करने का एक अच्छा तरीका क्या है?

एक विकल्प shared_ptr वापस करने के लिए है और दूसरा एक इनआउट संदर्भ है। लेकिन मैं कुछ अन्य विकल्प की तलाश में हूं। मैं कुछ ऐसा कर सकता हूं:

class AGetter 
{ 
    void getAExecute() 
    { 
     //... 
     // set a_ and i_ 
    } 
    std::auto_ptr<A> getA() const 
    { 
     return a_.release(); 
    } 
    int getInt() const 
    { 
     return i_; 
    } 
    private: 
    std::auto_ptr<A> a_; 
    int i_; 
}; 

क्या कोई बेहतर तरीका है?

Answer 1

बस एक नया वर्ग उस वर्ग

class Result 
{ 
    A* a; 
    int i; 
public: 
    Result(A*a, int i) : a(a), i(i) { 
    } 
    ~Result() { 
     delete a; 
    } 
    // access functions, copy constructor, ... 
}; 

Result getA() { 
    //...  
    return Result(new A, intValue); 
} 

Answer 2

यह बहुत नहीं है, लेकिन आप एक सूचक या संदर्भ तर्क के माध्यम से अन्य मान सकता है:

int i; 
std::auto_ptr<A> a = getA(&i); 

Answer 3

वहाँ दो प्रमुख तरीके से इस समस्या को संभालने के लिए कर रहे हैं:

1. सफाई स्वयं करें, कोशिश/पकड़ के माध्यम से।
2. shared_ptr जैसे किसी प्रकार के स्वचालित मेमोरी प्रबंधन का उपयोग करें।

auto_ptr वास्तव में इस तरह के मामलों में काम नहीं करता है, जैसा कि आपने पाया है, लेकिन नए मानक और बूस्ट दोनों संदर्भ-गिनती पॉइंटर्स हैं जो आप चाहते हैं। हमें बताएं कि आपको shared_ptr के बारे में क्या पसंद नहीं है, और शायद हम एक विकल्प सुझा सकते हैं।

Answer 4

दो संदर्भ पैरामीटर के माध्यम से क्यों नहीं?

class AGetter 
{ 
    // .. 
    void get(std::auto_ptr<A>& a, int& i) 
    { 
     a = a_.release(); 
     i = i_; 
    } 
    // .. 
}; 

Answer 5

एक shared_ptr उस स्थिति में आदर्श होगा, लेकिन आप वस्तु और इसके बजाय पूर्णांक युक्त एक जोड़ी के लिए एक auto_ptr लौट सकते हैं आप वास्तव में उन का उपयोग नहीं करना चाहते हैं।