Benötigen Sie einen Iterator, wenn Sie Fernkampf-basierte for-Schleifen verwenden

Derzeit kann ich nur Fernkampf-basierte Schleifen damit ausführen:

for (auto& value : values)

Aber manchmal brauche ich einen Iterator für den Wert anstelle einer Referenz (aus welchem ​​Grund auch immer). Gibt es eine Methode, ohne den gesamten Vektor durchlaufen zu müssen, um Werte zu vergleichen?

Verwenden Sie die alte forSchleife als:

for (auto it = values.begin(); it != values.end();  ++it )
{
       auto & value = *it;
       //...
}

Damit haben Sie valueebenso wie Iterator it. Verwenden Sie alles, was Sie verwenden möchten.

BEARBEITEN:

Ich würde dies zwar nicht empfehlen, aber wenn Sie eine bereichsbasierte forSchleife verwenden möchten (ja, aus welchem ​​Grund auch immer : D), können Sie dies tun:

 auto it = std::begin(values); //std::begin is a free function in C++11
 for (auto& value : values)
 {
     //Use value or it - whatever you need!
     //...
     ++it; //at the end OR make sure you do this in each iteration
 }

Dieser Ansatz vermeidet eine gegebene Suche value, da valueund itimmer synchron sind.

Hier ist eine Proxy-Wrapper-Klasse, mit der Sie den verborgenen Iterator durch Aliasing auf Ihre eigene Variable verfügbar machen können.

#include <memory>
#include <iterator>

/*  Only provides the bare minimum to support range-based for loops.
    Since the internal iterator of a range-based for is inaccessible,
    there is no point in more functionality here. */
template< typename iter >
struct range_iterator_reference_wrapper
    : std::reference_wrapper< iter > {
    iter &operator++() { return ++ this->get(); }
    decltype( * std::declval< iter >() ) operator*() { return * this->get(); }
    range_iterator_reference_wrapper( iter &in )
        : std::reference_wrapper< iter >( in ) {}
    friend bool operator!= ( range_iterator_reference_wrapper const &l,
                             range_iterator_reference_wrapper const &r )
        { return l.get() != r.get(); }
};

namespace unpolluted {
    /*  Cannot call unqualified free functions begin() and end() from 
        within a class with members begin() and end() without this hack. */
    template< typename u >
    auto b( u &c ) -> decltype( begin( c ) ) { return begin( c ); }
    template< typename u >
    auto e( u &c ) -> decltype( end( c ) ) { return end( c ); }
}

template< typename iter >
struct range_proxy {
    range_proxy( iter &in_first, iter in_last )
        : first( in_first ), last( in_last ) {}

    template< typename T >
    range_proxy( iter &out_first, T &in_container )
        : first( out_first ),
        last( unpolluted::e( in_container ) ) {
        out_first = unpolluted::b( in_container );
    }

    range_iterator_reference_wrapper< iter > begin() const
        { return first; }
    range_iterator_reference_wrapper< iter > end()
        { return last; }

    iter &first;
    iter last;
};

template< typename iter >
range_proxy< iter > visible_range( iter &in_first, iter in_last )
    { return range_proxy< iter >( in_first, in_last ); }

template< typename iter, typename container >
range_proxy< iter > visible_range( iter &first, container &in_container )
    { return range_proxy< iter >( first, in_container ); }

Verwendung:

#include <vector>
#include <iostream>
std::vector< int > values{ 1, 3, 9 };

int main() {
    // Either provide one iterator to see it through the whole container...
    std::vector< int >::iterator i;
    for ( auto &value : visible_range( i, values ) )
        std::cout << "# " << i - values.begin() << " = " << ++ value << '\n';

    // ... or two iterators to see the first incremented up to the second.
    auto j = values.begin(), end = values.end();
    for ( auto &value : visible_range( j, end ) )
        std::cout << "# " << j - values.begin() << " = " << ++ value << '\n';
}

Ich habe es versucht und eine Lösung gefunden.

Verwendung:

for(auto i : ForIterator(some_list)) {
    // i is the iterator, which was returned by some_list.begin()
    // might be useful for whatever reason
}

Die Umsetzung war nicht so schwierig:

template <typename T> struct Iterator {
    T& list;
    typedef decltype(list.begin()) I;

    struct InnerIterator {
        I i;
        InnerIterator(I i) : i(i) {}
        I operator * () { return i; }
        I operator ++ () { return ++i; }
        bool operator != (const InnerIterator& o) { return i != o.i; }
    };

    Iterator(T& list) : list(list) {}
    InnerIterator begin() { return InnerIterator(list.begin()); }
    InnerIterator end() { return InnerIterator(list.end()); }
};
template <typename T> Iterator<T> ForIterator(T& list) {
    return Iterator<T>(list);
}

Die bereichsbasierte for Schleife wird als C ++ - Gegenstück für foreachJava erstellt, das eine einfache Iteration von Array-Elementen ermöglicht. Es ist dazu gedacht, die Verwendung komplexer Strukturen wie Iteratoren zu entfernen, um es einfach zu machen. Wenn du willst iterator, wie Nawaz sagte, musst du eine normale forSchleife verwenden.

Es gibt eine sehr einfache Möglichkeit, dies zu tun std::vector, die auch funktionieren sollte, wenn Sie die Größe des Vektors während des Vorgangs ändern (ich bin nicht sicher, ob die akzeptierte Antwort diesen Fall berücksichtigt).

Wenn bes Ihr Vektor ist, können Sie es einfach tun

for(auto &i:b){
    auto iter = b.begin() + (&i-&*(b.begin()));
}

Wo iterwird Ihr erforderlicher Iterator sein?

Dies nutzt die Tatsache aus, dass C ++ - Vektoren immer zusammenhängend sind .

Lass es uns sehr schmutzig machen ... Ich weiß, die 0x70h ändert sich mit der Stack-Nutzung, der Compiler-Version, .... Sie sollte vom Compiler verfügbar gemacht werden, ist aber nicht :-(

char* uRBP = 0; __asm { mov uRBP, rbp }
Iterator** __pBegin = (Iterator**)(uRBP+0x70);
for (auto& oEntry : *this) {
    if (oEntry == *pVal) return (*__pBegin)->iPos;
}