कितना डेटा कॉपी किया जाता है, जब किसी std :: वेक्टर को किसी फ़ंक्शन में लौटाया जाता है और यह कितना बड़ा ऑप्टिमाइज़ेशन होगा, तो यह std :: वेक्टर को फ्री-स्टोर (हीप पर) में रखें और इसके बजाय एक पॉइंटर लौटाएँ:
std::vector *f()
{
std::vector *result = new std::vector();
/*
Insert elements into result
*/
return result;
} से अधिक कुशल:
std::vector f()
{
std::vector result;
/*
Insert elements into result
*/
return result;
} ?
जवाबों:
C ++ 11 में, यह पसंदीदा तरीका है:
std::vector<X> f();यही है, मूल्य के आधार पर लौटें।
C ++ 11 के साथ, std::vectorचाल-शब्दार्थ है, जिसका अर्थ है कि आपके फ़ंक्शन में घोषित स्थानीय वेक्टर रिटर्न पर ले जाया जाएगा और कुछ मामलों में भी इस कदम को संकलक द्वारा समाप्त किया जा सकता है।
return std::move(v);यह कदम के साथ भी संभव हो गया था, तो चाल-elision निष्क्रिय कर देगा return v;। तो बाद वाला पसंद किया जाता है।
आपको मूल्य से लौटना चाहिए।
मान द्वारा लौटने की दक्षता में सुधार करने के लिए मानक में एक विशिष्ट विशेषता है। इसे "कॉपी एलीशन" कहा जाता है, और विशेष रूप से इस मामले में "नाम वापसी मूल्य अनुकूलन (NRVO)"।
कंपाइलर्स को इसे लागू करने की जरूरत नहीं है, लेकिन फिर कंपाइलरों के पास नहीं है कंपाइलरों को फ़ंक्शन इनलाइनिंग (या किसी भी अनुकूलन को पूरा करने) को लागू करने की । लेकिन मानक पुस्तकालयों का प्रदर्शन बहुत खराब हो सकता है यदि कंपाइलर अनुकूलन नहीं करते हैं, और सभी गंभीर कंपाइलर इनलाइनिंग और एनआरवीओ (और अन्य अनुकूलन) को लागू करते हैं।
जब NRVO लागू किया जाता है, तो निम्नलिखित कोड में कोई प्रतिलिपि नहीं होगी:
std::vector<int> f() {
std::vector<int> result;
... populate the vector ...
return result;
}
std::vector<int> myvec = f();लेकिन उपयोगकर्ता ऐसा करना चाह सकता है:
std::vector<int> myvec;
... some time later ...
myvec = f();कॉपी एलिसेंस यहां कॉपी को रोक नहीं सकता क्योंकि यह इनिशियलाइजेशन के बजाय असाइनमेंट है। हालाँकि, आपको चाहिए अभी भी मूल्य से वापस । सी ++ 11 में, असाइनमेंट को कुछ अलग से अनुकूलित किया जाता है, जिसे "मूव शब्दार्थ" कहा जाता है। C ++ 03 में, उपरोक्त कोड एक कॉपी का कारण बनता है, और हालांकि सिद्धांत में एक अनुकूलक इससे बचने में सक्षम हो सकता है, व्यवहार में यह बहुत मुश्किल है। तो इसके बजाय myvec = f(), C ++ 03 में आपको यह लिखना चाहिए:
std::vector<int> myvec;
... some time later ...
f().swap(myvec);एक और विकल्प है, जो उपयोगकर्ता को अधिक लचीला इंटरफ़ेस प्रदान करना है:
template <typename OutputIterator> void f(OutputIterator it) {
... write elements to the iterator like this ...
*it++ = 0;
*it++ = 1;
}आप उसके बाद मौजूदा वेक्टर-आधारित इंटरफ़ेस का भी समर्थन कर सकते हैं:
std::vector<int> f() {
std::vector<int> result;
f(std::back_inserter(result));
return result;
}यह आपके मौजूदा कोड की तुलना में कम कुशल हो सकता है, अगर आपका मौजूदा कोड reserve()एक निश्चित राशि से अधिक जटिल तरीके से उपयोग करता है। लेकिन अगर आपका मौजूदा कोड मूल रूप push_backसे वेक्टर पर बार-बार कॉल करता है, तो यह टेम्पलेट-आधारित कोड उतना ही अच्छा होना चाहिए।
यह समय है जब मैं आरवीओ के बारे में एक उत्तर देता हूं , मुझे भी ...
यदि आप किसी वस्तु को मान से लौटाते हैं, तो संकलक अक्सर यह आशा करता है कि इसका निर्माण दो बार नहीं हो सकता है, क्योंकि यह एक अस्थायी के रूप में फ़ंक्शन में इसका निर्माण करने के लिए बहुत अधिक है और फिर इसे कॉपी करता है। इसे रिटर्न वैल्यू ऑप्टिमाइज़ेशन कहा जाता है: बनाए गए ऑब्जेक्ट को कॉपी किए जाने के बजाय स्थानांतरित किया जाएगा।
एक सामान्य प्री-सी ++ 11 मुहावरा है कि भरी जाने वाली वस्तु का संदर्भ दिया जाए।
फिर वेक्टर की कोई प्रतिलिपि नहीं है।
void f( std::vector & result )
{
/*
Insert elements into result
*/
} यदि कंपाइलर नामांकित रिटर्न वैल्यू ऑप्टिमाइजेशन ( http://msdn.microsoft.com/en-us/library/ms364057(v=vs.80).aspx ) का समर्थन करता है , तो आप सीधे वेक्टर प्रदान कर सकते हैं बशर्ते कि कोई है:
NRVO निरर्थक कॉपी कंस्ट्रक्टर और विध्वंसक कॉल को अनुकूलित करता है और इस प्रकार समग्र प्रदर्शन में सुधार करता है।
आपके उदाहरण में कोई वास्तविक अंतर नहीं होना चाहिए।
vector<string> getseq(char * db_file)और यदि आप इसे मुख्य () पर प्रिंट करना चाहते हैं, तो आपको इसे लूप में करना चाहिए।
int main() {
vector<string> str_vec = getseq(argv[1]);
for(vector<string>::iterator it = str_vec.begin(); it != str_vec.end(); it++) {
cout << *it << endl;
}
}"वैल्यू बाय रिटर्न" जितना अच्छा हो सकता है, यह उस तरह का कोड है जो किसी को त्रुटि में ले जा सकता है। निम्नलिखित कार्यक्रम पर विचार करें:
#include <string>
#include <vector>
#include <iostream>
using namespace std;
static std::vector<std::string> strings;
std::vector<std::string> vecFunc(void) { return strings; };
int main(int argc, char * argv[]){
// set up the vector of strings to hold however
// many strings the user provides on the command line
for(int idx=1; (idx<argc); ++idx){
strings.push_back(argv[idx]);
}
// now, iterate the strings and print them using the vector function
// as accessor
for(std::vector<std::string>::interator idx=vecFunc().begin(); (idx!=vecFunc().end()); ++idx){
cout << "Addr: " << idx->c_str() << std::endl;
cout << "Val: " << *idx << std::endl;
}
return 0;
};यदि कोई व्यक्ति GNU g ++ रिपोर्टिंग विकल्पों का उपयोग करता है तो भी उपरोक्त त्रुटिपूर्ण कार्यक्रम कोई त्रुटि नहीं दर्शाएगा। -Wextra -Weffff ++
यदि आप एक मूल्य का उत्पादन करते हैं, तो निम्न दो बार vecFunc () को कॉल करने के स्थान पर काम करेगा:
std::vector<std::string> lclvec(vecFunc());
for(std::vector<std::string>::iterator idx=lclvec.begin(); (idx!=lclvec.end()); ++idx)...उपरोक्त भी लूप के पुनरावृत्ति के दौरान कोई अनाम वस्तु नहीं बनाता है, लेकिन इसके लिए एक संभावित कॉपी ऑपरेशन की आवश्यकता होती है (जो कुछ नोट के रूप में, कुछ परिस्थितियों में दूर अनुकूलित किया जा सकता है। लेकिन संदर्भ विधि की गारंटी है कि कोई भी कॉपी नहीं बनाई जाएगी। संकलक को मानना) प्रदर्शन आरवीओ आपके लिए सबसे कुशल कोड बनाने की कोशिश करने के लिए कोई विकल्प नहीं है। यदि आप आरवीओ करने के लिए कंपाइलर की आवश्यकता को लूट सकते हैं, तो आप गेम से आगे हैं।
f?