Sử dụng tự động (ví lặp) trong lồng nhau nhiều dựa trên vòng lặp for

Question

Hiện nay tôi đã bắt đầu sử dụng auto keyword.I có một số nghi ngờ về điều đó:

Nếu tôi cần phải đi qua vector tôi làm:

vector<int>v; 

for(auto it : v){  

    cout << it <<endl; 

} 

Nhưng giả sử nếu tôi cần phải làm một cái gì đó như:

vector<int>v; 

for(auto it:v){  
    for(auto jt:X){ 

    //where X is next position of it's position 
    //What I mean is if it is currently at 2nd position then 
    //jt iterator will start from 3rd position 

    }  
} 

tôi hoàn toàn không có ý tưởng làm thế nào để làm that.Please Đề nghị các phương pháp thích hợp cho điều đó là những gì .Cảm ơn trước.

Answer 1

Tôi giả sử bạn muốn sử dụng autovà vòng lặp mới dựa trên phạm vi for.

Bạn có thể tạo vector_view và lặp qua "vector phụ" trong vòng lặp bên trong.

Dưới đây là một ví dụ đơn giản để giúp bạn bắt đầu (chú ý việc sử dụng auto& và không auto):

Run It Online

#include <iostream> 
#include <cstddef> 
#include <numeric> 
#include <vector> 
using std::cout; 
using std::endl; 

template <typename T, typename A> 
struct vector_view 
{ 
    using vector_type = std::vector<T, A>; 
    using const_iterator = typename vector_type::const_iterator; 
    using  iterator = typename vector_type::iterator; 

    vector_type& vec; 
    size_t  _begin; 
    size_t  _length; 

    vector_view(vector_type& v, size_t begin_, size_t length_) 
    : vec(v), _begin(begin_), _length(length_) {} 

    const_iterator begin() const { return vec.begin() + _begin; } 
    iterator  begin()  { return vec.begin() + _begin; } 

    const_iterator end() const { return vec.begin() + _begin + _length; } 
    iterator  end()   { return vec.begin() + _begin + _length; } 
}; 

int main() 
{ 
    std::vector<int> v(10); 
    std::iota(v.begin(), v.end(), 0); 

    for (auto& it : v) 
    { 
     size_t begin = std::distance(&v[0], &it) + 1; 
     size_t length = v.size() - begin; 
     vector_view<typename decltype(v)::value_type, 
        typename decltype(v)::allocator_type 
     > vv(v, begin, length); 

     cout << it << ": "; 
     for (auto& jt : vv) 
     { 
      cout << jt << " "; 
     } 
     cout << endl; 
    } 
} 

Output:

0: 1 2 3 4 5 6 7 8 9 
1: 2 3 4 5 6 7 8 9 
2: 3 4 5 6 7 8 9 
3: 4 5 6 7 8 9 
4: 5 6 7 8 9 
5: 6 7 8 9 
6: 7 8 9 
7: 8 9 
8: 9 
9: 

EDIT: Bạn có thể làm cho cú pháp ax ít tiết nếu bạn định nghĩa một hàm make_vector_view():

template <typename T, typename A> 
vector_view<T, A> make_vector_view(std::vector<T, A>& v, 
            size_t    begin_, 
            size_t    length_) 
{ 
    return {v, begin_, length_}; 
} 

Và nhờ vào mẫu đối số kiểu khấu trừ, bạn có thể viết:

Run It Online

for (auto& it : v) 
{ 
    size_t begin = std::distance(&v[0], &it) + 1; 
    size_t length = v.size() - begin; 

    cout << it << ": "; 
    for (auto& jt : make_vector_view(v, begin, length)) 
    { 
     cout << jt << " "; 
    } 
    cout << endl; 
} 

Answer 2

auto it:v 

là viết tắt cho. ..

auto it = v.begin(); it != v.end(); it++ 

vậy để sử dụng auto bên trong lồng nhau cho vòng, phiên bản còn thích hợp hơn ...

#include <iostream> 
#include <vector> 

using namespace std; 

int main() 
{ 
    vector<int> v(10, 17); 
    for (auto& it = v.begin(); it != v.end(); ++it) { 
     for (auto& it2 = it + 1; it2 != v.end(); ++it2) { 
      cout << *it2 << " "; 
     } 
     cout << endl; 
    } 

    // system("pause"); 
    return 0; 
}