ऑटो बनाम कंक्रीट प्रकार जब वेक्टर पर पुनरावृत्त?

Question

पुस्तक मैं जब एक vector

for (auto &e: v) { 
    cout << e << endl; 
} 

मान लीजिए वी से अधिक पुनरावृत्ति vector<int> v के रूप में घोषित किया जाता है, दूसरे शब्दों में प्रदान करता है इस उदाहरण पढ़ रहा हूँ, हम जानते हैं कि इस संग्रह के अंदर तत्वों के प्रकार int है।

auto का उपयोग किसी भी तरह से बेहतर या पसंदीदा में किया जा रहा है?

for (int &e: v) { 
    cout << e << endl; 
} 

क्यों?

Answer 1

हां। auto को प्राथमिकता दी जाती है। यह करने के लिए

std::vector<int> v; //before 

: अगर आप से v की घोषणा बदल क्योंकि

std::vector<float> v; //after 

आप for में int & का उपयोग करते हैं, तो आप उस बदलने के लिए भी है। लेकिन auto के साथ, बदलने की कोई ज़रूरत नहीं है!

मेरी राय में, auto के साथ काम करना programming to interface जैसा कम या कम है।

for(auto & e : v) 
{ 
     e += 2; 
} 

इस में: तो अगर आप पाश में एक ऑपरेशन += करते हैं, और तुम सच में नहीं है जब तक प्रकार += कार्रवाई का समर्थन करता के रूप में पाश चर e के प्रकार के बारे में परवाह है, तो auto समाधान है उदाहरण के लिए, आप सभी को इस बात की परवाह है कि e+= का समर्थन int के साथ दाएं हाथ पर है। यह उपयोगकर्ता द्वारा परिभाषित प्रकारों के लिए भी काम करेगा, जिसने operator+=(int), या operator+=(T) को परिभाषित किया है, जहां T एक प्रकार है जो int से अंतर्निहित रूपांतरण का समर्थन करता है।यह आप इंटरफेस करने प्रोग्रामिंग कर रहे हैं के रूप में अगर है:

for(Animal * animal : animals) 
{ 
     animal->eat(food); //still program to interface 
} 

या बस इस:

for(auto animal : animals) 
{ 
     animal->eat(food); //still program to interface 
} 

यह है

std::vector<Animal*> animals; 
animals.push_back(new Dog()); 
animals.push_back(new Cat()); 
animals.push_back(new Horse()); 

for(size_t i = 0 ; i < animals.size(); ++i) 
{ 
     animals[i]->eat(food); //program to interface 
} 

बेशक

, आप के रूप में इस पाश लिखने के लिए चाहते हैं अभी भी programming to interface।

लेकिन एक ही समय में, @ डेविड की टिप्पणी में बात ध्यान देने योग्य है।

Answer 2

आपके पहले उदाहरण पर, आपके पास वेक्टर के तत्वों पर कम निर्भरता है।

मान लीजिए कि एक महीने में, आपको आवश्यकता है कि आपके वेक्टर बड़े पूर्णांक स्टोर करें, इसलिए आपको std::vector<int64_t>, या कुछ अन्य, व्यापक प्रकार का उपयोग करना होगा। अब उस वेक्टर पर पुनरावृत्त कोड के सभी अमान्य है। आप प्रत्येक को संशोधित करना होगा:

for (int &e: v) {} 

एक के लिए:

for (int64_t &e: v) {} 

यही वजह है कि यह बेहतर है बस जाने के लिए auto आंतरिक प्रकार अनुमान। इस तरह आप अपने वेक्टर में किसी अन्य, संगत एक के लिए संग्रहीत प्रकार को संशोधित कर सकते हैं, और आपका सभी कोड अभी भी काम करेगा।