Cần trình lặp khi sử dụng vòng lặp for dựa trên phạm vi

Hiện tại, tôi chỉ có thể thực hiện các vòng lặp dựa trên phạm vi với cái này:

for (auto& value : values)

Nhưng đôi khi tôi cần một trình lặp cho giá trị, thay vì một tham chiếu (Vì bất kỳ lý do gì). Có phương pháp nào mà không cần phải đi qua toàn bộ vector so sánh các giá trị không?

Sử dụng forvòng lặp cũ như:

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

Với điều này, bạn valuecũng như trình lặp it. Sử dụng bất cứ điều gì bạn muốn sử dụng.

BIÊN TẬP:

Mặc dù tôi không đề xuất điều này, nhưng nếu bạn muốn sử dụng forvòng lặp dựa trên phạm vi (vâng, Vì lý do gì : D), thì bạn có thể làm điều này:

 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
 }

Cách tiếp cận này tránh tìm kiếm đã cho value, vì valuevà itluôn đồng bộ.

Đây là một lớp trình bao bọc proxy để cho phép bạn hiển thị trình vòng lặp ẩn bằng cách đặt bí danh cho biến của riêng bạn.

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

Sử dụng:

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

Tôi đã thử bản thân mình về điều này và tìm ra giải pháp.

Sử dụng:

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

Việc thực hiện không quá khó:

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

forvòng lặp dựa trên phạm vi được tạo như bản đối chiếu c ++ foreachtrong java cho phép lặp lại các phần tử mảng dễ dàng. Nó có nghĩa là để loại bỏ việc sử dụng các cấu trúc phức tạp như trình vòng lặp để làm cho nó trở nên đơn giản. Tôi bạn muốn một iterator, như Nawaz đã nói, bạn sẽ phải sử dụng forvòng lặp bình thường .

Có một cách rất đơn giản để làm điều này std::vector, cũng sẽ hoạt động nếu bạn đang thay đổi kích thước vectơ trong quá trình này (tôi không chắc liệu câu trả lời được chấp nhận có xem xét trường hợp này hay không)

Nếu blà vectơ của bạn, bạn chỉ có thể làm

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

đâu itersẽ là trình lặp yêu cầu của bạn.

Điều này tận dụng lợi thế của thực tế là các vectơ C ++ luôn luôn kề nhau .

Hãy làm điều đó rất bẩn ... Tôi biết, 0x70h đang thay đổi với cách sử dụng ngăn xếp, phiên bản trình biên dịch, .... Nó nên được trình biên dịch hiển thị, nhưng nó không :-(

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