समारोह के भीतर आबंटित स्मृति प्रबंधन करने के लिए एक स्मार्ट सूचक का उपयोग करना

Question

पृष्ठभूमि

अगर मैं एक समारोह foo था के रूप में

void foo(std::vector<int>& values) 
{ 
    values = std::vector<int>(10, 1); 
} 

इस प्रकार है तो मैं के रूप में

std::vector<int> values; 
foo(values); 

सूचना यह कह सकते हैं कि प्रारंभिक vector खाली है, फिर यह foo फ़ंक्शन के भीतर पॉप्युलेट किया गया है।

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

void foo(int*& values) 
{ 
    values = new int[10]; 
    std::fill_n(values, 10, 1); 
} 

इन के साथ मेरी समस्या यह है कि अब मैं कर रहा हूँ है उस स्मृति के प्रबंधन के लिए जिम्मेदार, उदाहरण के लिए

int* values; 
foo(values); 
delete[] values; 

प्रश्न

वहाँ किसी भी तरह से मैं स्मार्ट संकेत का उपयोग कर सकते मेरे लिए यह स्मृति प्रबंधन करने के लिए है? मैं की तरह

std::unique_ptr<int[]> values; 
foo(values.get()); 

लेकिन एक सूचक एक r-मूल्य है कि get रिटर्न कुछ करना चाहते हैं, तो मैं गैर स्थिरांक संदर्भ द्वारा इसे पारित नहीं कर सकते।

Answer 1

1. खाली अद्वितीय_ptr बनाएँ।
2. पॉइंटर बनाएं।
3. कार्य करने के लिए पॉइंटर पास करें।
4. उस पॉइंटर में unique_ptr रीसेट करें।

कि जैसा

:

std::unique_ptr<int[]> values; 
int* values_ptr; 
foo(values_ptr); 
values.reset(values_ptr); 

या:

int* values_ptr; 
foo(values_ptr); 
std::unique_ptr<int[]> values(values_ptr); 

Answer 2

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

template <typename T, typename Function> 
std::unique_ptr<T[]> call(Function f) { 
    T * value; 
    f(value); 
    return { value }; 
} 

// then to use it 
auto value = call<int>(foo); 

क्या यह आपके अनुरूप होगा?

फ़ंक्शन को एक ऑब्जेक्ट या किसी सरणी के लिए अंतर की पहचान करने के लिए फ़ंक्शन को बेहतर किया जा सकता है यदि आपको इसकी आवश्यकता हो, और संभवतः इसे आवश्यक पैरामीटर प्रकार का पता लगाने के लिए भी बेहतर किया जा सकता है ताकि आपको इसे टाइप न करना पड़े ।