लौटने वाले सी ++ इटरेटर

Question

मेरे पास एक ऐसा फ़ंक्शन है जो ऑब्जेक्ट मिलने पर एक इटरेटर लौटाता है।

अब मुझे कोई समस्या है। मैं उस ऑब्जेक्ट को सूचित करने की समस्या को कैसे ठीक करूं जिसे इस फ़ंक्शन कहा जाता है कि ऑब्जेक्ट नहीं मिला था?

vector<obj>::iterator Find(int id, int test) 
{ 
     vector<obj>::iterator it; 
      aClass class; 

      for(it = class.vecCont.begin(); it != class.vecCont.end(); ++it) 
      { 
       if(found object) //currently in psuedo code 
       return it; 
      } 

      return ???? // <<< if not found what to insert here? 

} 

क्या मुझे इसके बजाय अपनी डेटा संरचना बदलने की ज़रूरत है?

अग्रिम धन्यवाद! :)

Answer 1

एक छिपे हुए कंटेनर पर एक इटरेटर वापस न करें। केवल वही लौटें जो आप चाहते हैं, अर्थात् यदि किसी वस्तु का अस्तित्व है तो इसका उपयोग करने का साधन। इस उदाहरण में, मैं ऑब्जेक्ट को कंटेनर में पॉइंटर के माध्यम से स्टोर करता हूं।यदि आपकी वस्तुएं केवल अस्थायी रूप से मौजूद हैं, तो नया एक ऊपर और वस्तु को कॉपी करें!

class AClass; 

//...some time later 
std::vector<AClass*> vecCont; //notice, store pointers in this example! 

//..some time later 
AClass * findAClass(int id, int test) 
{ 
    vector<AClass*>::iterator it; 

    for(it = class.vecCont.begin(); it != class.vecCont.end(); ++it) 
    { 
    if(found object) //currently in psuedo code 
    return it; 
    } 

    return NULL; 
} 

//later still.. 

AClass *foundVal = findAClass(1, 0); 
if(foundVal) 
{ 
    //we found it! 
} 
else 
{ 
    //we didn't find it 
} 

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

Answer 2

आप इसे इंगित करने के लिए एक इटरेटर को वापस कर सकते हैं, यानी return class.vecCont.end()।

Answer 3

वापसी vector::end(), एक अपवाद फेंक, या वापसी अलावा कुछ एक सादे इटरेटर

की तुलना में बेहतर अभी तक, अपने स्वयं के Find समारोह को लागू नहीं करते। <algorithm> लाइब्रेरी के लिए यही है। आपके psudocode के आधार पर, आप शायद std::find या std::find_if का उपयोग कर सकते हैं। find_if उन मामलों में विशेष रूप से उपयोगी है जहां समानता का मतलब operator== नहीं है। उन मामलों में, आप एक [सी ++ 11] लैम्ब्डा का उपयोग कर सकते हैं या यदि सी ++ 11 आपके लिए उपलब्ध नहीं है, तो एक मजेदार वर्ग।

के बाद से functor सबसे कम आम विभाजक है, मैं उस के साथ शुरू करेंगे:

#include <cstdlib> 
#include <string> 
#include <algorithm> 
#include <vector> 
#include <functional> 
using namespace std; 

class Person 
{ 
public: 
    Person(const string& name, unsigned age) : name_(name), age_(age) {}; 

    string name_; 
    unsigned age_; 
}; 

class match_name : public unary_function <bool, string> 
{ 
public: 
    match_name(const string& rhs) : name_(rhs) {}; 
    bool operator()(const Person& rhs) const 
    { 
    return rhs.name_ == name_; 
    } 
private: 
    string name_; 
}; 

#include <iostream> 

int main() 
{ 
    vector<Person> people; 
    people.push_back(Person("Hellen Keller", 99)); 
    people.push_back(Person("John Doe", 42)); 

    /** C++03 **/ 
    vector<Person>::const_iterator found_person = std::find_if(people.begin(), people.end(), match_name("John Doe")); 

    if(found_person == people.end()) 
     cout << "Not FOund"; 
    else 
     cout << found_person->name_ << " is " << found_person->age_; 
} 

found_person अब व्यक्ति जिसका नाम "जॉन डो" है की ओर इशारा करता है, या यदि उस व्यक्ति नहीं दिया किसी और people_.end() को इंगित करता है नहीं मिला

ए सी ++ 11 लैम्ब्डा नई भाषा वाक्यविन्यास है जो एक मज़ेदार घोषित करने/परिभाषित करने की प्रक्रिया को बनाता है और कई मामलों के लिए उपयोग करना कुछ आसान है। यह इस तरह से किया जाता है:

string target = "John Doe"; 
vector<Person>::const_iterator found_person = std::find_if(people.begin(), people.end(), [&target](const Person& test) { return it->name_ == target; }); 

Answer 4

आप class.vecCont.end() लौटना चाहिए अगर वस्तु नहीं मिला था। लेकिन @ क्रिसिस सही है - यह वास्तव में std::find है।

Answer 5

केवल अंत पुनरावर्तक को वापस करने के बारे में कैसे?

आपका कोड हो जाता है: -

vector<obj>::iterator Find(int id, int test) 
{ 
    vector<obj>::iterator it; 
    aClass class; 

    for(it = class.vecCont.begin(); it != class.vecCont.end(); ++it) 
    { 
    if(found object) //currently in psuedo code 
     break; 
    } 

    return it; 
} 

या सिर्फ std::find का उपयोग करें। इस

std::vector<obj>::iterator pos; 
pos = find(coll.begin(),coll.end(), val); 

तरह

Answer 6

कुछ और कंटेनर

if (pos != coll.end()) 

Answer 7

में या अपने तत्व की उपस्थिति नहीं के लिए इन जांच करने के लिए भूल जाते हैं कभी नहीं एक वर्ग के अंदर std::algorithm कार्यों का अनुकरण नहीं है। वे एक कारण के लिए नि: शुल्क कार्य हैं। यह आमतौर पर begin और end सदस्य फ़ंक्शन का खुलासा करने के लिए पर्याप्त है जो दाएं इटरेटर्स (और संभवतः boost::iterator_range) लौटाता है। यदि आपको एक मजेदार के साथ एक फैंसी खोजने की ज़रूरत है, तो मज़ेदार को भी बेनकाब करें।