Question

我想知道在输入迭代方向时是否有人想过如何迭代向量（或容器）的元素。

这是我能想到的第一件事：

std::vector<int> vec = {1, 5, 7, 23};
int direction = 1 // or -1;
int start = direction == 1 ?  0 : (int)arrs.size()-1;
for (int i=start; i<(int)vec.size() && 0<=i; i+=direction) {
    //do_stuff_fn(i, vec.at(i))
}

有谁知道更好或更好的方法吗？请我在循环中访问索引 i 。我担心这意味着std :: for_each不是一个选项。

Answer 1

由于你想使用c ++和std库，没有比reverse_iterator更合适的了。

示例：

std::vector<int> vec = {1, 5, 7, 23};
int direction = 1 // or -1;
auto begin =  (direction > 0) ? vec.begin() : ver.rbegin();
auto end =  (direction > 0) ? vec.end() : ver.rend();
for (auto it = begin; it != end; it++)
{
    do_stuff_fn(it - vec.begin(), *it);
}

Answer 2

void printer(std::vector<int>& v, int d) {
    for (auto i = d > 0 ? 0 : v.size() - 1;
            i != (d > 0 ? v.size() : -1);
            i += d) {
        std::cout << v[i] << std::endl;
    }   
}

Answer 3

你可以试试这个：

class idx{
private:
   bool forwardDir;
   int current;
   bool complete;
   int s;
public:
   idx(int size,bool forward)
   {
       s = size;
       complete = false;
       forwardDir = forward;
       if(forward)
          current = 0;
       else
          current = size-1;
   }
   int operator ++(int)
   {
       if(forwardDir)
       {
           ++current;
           if(current==s)
               complete = true;
           return current;
       }
       else
       {
           --current;
           if(current ==-1)
              complete=true
           return current;
       }
   }
   bool notComplete()
   {
       return !complete;
   }
   explicit operator int() const { return current; }
}

现在你可以在向量迭代中使用这个idx类。 e.g。

std::vector<int> vec = {1, 5, 7, 23};
int direction = 1 // or -1; 
bool dir;
if(direction == 1)
    dir = 1;
else
    dir = 0
idx i(vec.size(),dir);
for (;i.notComplete();i++)
{
    // do staff with vec.at(i);
}

Answer 4

确实有一个非常简单的解决方案：使用两个循环。

void doit(size_t index, std::vector<int>& v) { ... what ever ... }

void function(std::vector<int>& v, bool const ascending) {
    if (ascending) {
        for (size_t i = 0, max = v.size(); i != size; ++i) { doit(i, v); }
    } else {
        for (size_t i = v.size(); i > 0; --i) { doit(i-1, v); }
    }                                         //      ^^ crucial bit here!
}

使用C ++ 11，doit将是一个通过引用捕获v的lambda：

void function(std::vector<int>& v, bool const ascending) {
    auto doit = [&v](size_t index) { .... };

    if (ascending) {
        for (size_t i = 0, max = v.size(); i != size; ++i) { doit(i); }
    } else {
        for (size_t i = v.size(); i > 0; --i) { doit(i-1); }
    }                                         //      ^^ crucial bit here!
}

C ++正向和反向迭代通过容器

4 个答案: