Потрібен ітератор, коли використовується цикл на основі діапазону

На даний момент я можу робити лише цикли на основі діапазону з цим:

for (auto& value : values)

Але іноді мені потрібен ітератор значення, а не посилання (З якоїсь причини). Чи існує який-небудь метод без необхідності проходити весь вектор, порівнюючи значення?

Використовуйте старий forцикл як:

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

З цим у вас є valueітератор it. Використовуйте все, що хочете.

РЕДАГУВАТИ:

Хоча я б цього не рекомендував, але якщо ви хочете використовувати forцикл на основі діапазону (так, з якоїсь причини : D), тоді ви можете зробити це:

 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
 }

Такий підхід дозволяє уникнути Searching дається value, так як valueі itзавжди синхронізовані.

Ось клас обгортки проксі-сервера, який дозволяє вам виставити прихований ітератор, об’єднавши його у власну змінну.

#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 ); }

Використання:

#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';
}

Я спробував це і знайшов рішення.

Використання:

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

Реалізація була не такою складною:

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);
}

forЦикл на основі діапазону створюється як аналог c ++ для foreachin Java, що дозволяє легко ітерацію елементів масиву. Він призначений для усунення використання складних структур, таких як ітератори, щоб зробити це простішим. Якщо ви хочете iterator, як сказав Наваз, вам доведеться використовувати звичайний forцикл.

Існує дуже простий спосіб зробити це std::vector, який також повинен працювати, якщо ви змінюєте розмір вектора під час процесу (я не впевнений, чи прийнята відповідь розглядає цей випадок)

Якщо bце ваш вектор, ви можете просто зробити

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

де iterбуде ваш необхідний ітератор.

Це використовує той факт, що вектори С ++ завжди суміжні .

Давайте зробимо це дуже брудно ... Я знаю, 0x70h змінюється із використанням стека, версія компілятора, .... Його повинен виставити компілятор, але це не так :-(

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