Iterator Überlastung Elementauswahl vs Indirektionsoperator

Question

So im Interesse eines Minimal. Complete, Verifiable Example Schaffung ich ein Spielzeug geschaffen haben iterator hier (ich weiß, es ist nicht perfekt, es ist nur für die Zwecke einer Frage):

class foo : public iterator<input_iterator_tag, string> { 
    string _foo; 
    static const size_t _size = 13; 
public: 
    const string& operator*() { return _foo; } 
    const foo& operator++() { 
     _foo += '*'; 
     return *this; 
    } 
    const foo operator++(int) { 
     auto result = *this; 
     _foo += '*'; 
     return result; 
    } 
    bool operator==(const foo& rhs) { return _foo.empty() != rhs._foo.empty() && _foo.size() % _size == rhs._foo.size() % _size; } 
    bool operator!=(const foo& rhs) { return !operator==(rhs); } 
}; 

Ich habe gelesen, dass ein InputIterator den Member Selection Operator definiert haben muss. Der Indirection Operator ist sinnvoll, aber ein Member Selection Operator ist für mich verwirrend. Wie würde ein Member Selection Operator für foo implementiert?

Answer 1

const string* operator->() const { return &_foo; } 

Beispiel Nutzung:

foo i; 
++i; 
assert(i->length() == 1); 

Die Art und Weise dies funktioniert, ist, dass die Compiler Anrufe operator-> wiederholt wird erzeugen, bis der Rückgabetyp ein Rohzeiger (so in diesem Fall nur ein Anruf zu foo::operator->) ist Führen Sie dann die reguläre Elementauswahloperation für diesen Zeiger aus.

Answer 2

Die operator->() sollte einen Zeigertyp des Typs zurückgeben, den der Container enthält, für den der Iterator verwendet wird. Wenn Sie also einen Container haben, der eine std::string enthält, dann sollte die iterator::operator-> eine std::sting* zurückgeben. In Ihrem Fall, da Sie von std::iterator herleiten, können Sie die pointer typedef für den Rückgabetyp verwenden.