Auto (für Iterieren) in verschachtelten bereichsbasierte for-Schleife

Question

Derzeit bezüglich ich begonnen haben, mit auto keyword.I dass einige Zweifel haben:

Wenn ich die vector zu durchqueren muss ich tun:

vector<int>v; 

for(auto it : v){  

    cout << it <<endl; 

} 

Aber nehmen wir an, wenn ich so etwas tun müssen:

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 

    }  
} 

ich habe absolut keine Ahnung, wie that.Please vorschlagen zu tun, was für, dass das entsprechende Verfahren ist .Danke im Voraus.

Answer 1

Ich nehme an, dass Sie autound die neue bereichsbasierte for Schleife verwenden möchten.

Sie können einen vector_view erstellen und über den "Untervektor" in der inneren Schleife iterieren.

Hier ist ein einfaches Beispiel, das Sie begann (man beachte die Verwendung von auto& und nicht auto) zu erhalten:

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

Ausgang:

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: Sie können den synt machen ax weniger ausführlich, wenn Sie eine make_vector_view() Funktion definieren:

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

Und dank Typ Abzug Template-Argument, können Sie schreiben:

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 

ist eine Abkürzung für. ..

so zu verwenden Auto innen verschachtelte for-Schleifen, die längere Version ist besser geeignet ...

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