我可以从基于循环的范围内获取项目的索引吗？

Question

我已经定义了一个像这样的指针deque:

std::deque<BoardSquare *> mydeque;

我想在我的双端队列中使用基于范围的循环:

for (BoardSquare * b : mydeque) {

    // do something involving the index of b
}

是否有可能从基于循环的范围内获取项目的索引？

Answer 1

不,它不是(至少不合理).当你真的需要索引时,你可能根本不应该使用基于范围的for循环,而是使用一个好的旧迭代器或基于索引的for循环:

// non-idiomatic index-iteration, random access containers only
for(std::size_t i=0; i<mydeque.size(); ++i)
    mydeque[i];

// awfully ugly additional iteration variable, yet generic and fast
std::size_t i = 0;
for(auto iter=mydeque.begin(); iter!=mydeque.end(); ++iter,++i)
    *iter;

// idiomatic and generic, yet slow for non-random access containers
for(auto iter=mydeque.begin(); iter!=mydeque.end(); ++iter)
{
    auto i = std::distance(mydeque.begin(), iter);
    *iter;
}

在清晰度,惯用性,流线型和性能方面,所有这些都有其优点和缺点.

Answer 2

我想出了一个解决方案 - 或者说是一个实验性解决方案.以下是您最终将如何使用它:

for(auto item : make_indexable(v))
{
      //std::get<0>(item) is the index
      //std::get<1>(item) is the object
}

这里是最小的实现(它只是为了演示基本的想法):

#include <tuple>
#include <functional>

template<typename C>
struct indexed_container
{
    struct indexed_iterator
    {
        typedef typename C::value_type value_type;
        typedef std::tuple<size_t, std::reference_wrapper<value_type>> tuple_type;

        typename C::iterator _it;
        size_t _index;

        indexed_iterator(typename C::iterator it) : _it(it), _index(0) {}

        indexed_iterator& operator++()
        {
            ++_it;
            ++_index;
            return *this;
        }
        bool operator == (indexed_iterator const & other)
        {
            return _it == other._it;
        }
        bool operator != (indexed_iterator const & other)
        {
            return _it != other._it;
        }
        tuple_type operator*()
        {
            return std::make_tuple(_index, std::ref(*_it));
        }
    };

    indexed_container(C & c) : _c(c) {}

    indexed_iterator begin()
    {
        return indexed_iterator(_c.begin());
    }
    indexed_iterator end()
    {
        return indexed_iterator(_c.end());
    }
private:
    C & _c;
};

template<typename C>
auto make_indexable(C & c) -> indexed_container<C>
{
    return indexed_container<C>(c); 
}

测试代码:

#include <iostream>
#include <vector>

int main()
{
    std::vector<int> v{1,2,3};
    for(auto item : make_indexable(v))
    {
        std::cout << std::get<0>(item) << " => " << std::get<1>(item) << std::endl;

        std::get<1>(item) *= 10; //modify value!
    }
    std::cout << "\nModified\n";
    for(auto item : make_indexable(v))
    {
        std::cout << std::get<0>(item) << " => " << std::get<1>(item) << std::endl;
    }
}

输出:

0 => 1
1 => 2
2 => 3

Modified
0 => 10
1 => 20
2 => 30

在线演示

请注意,此解决方案并不完美,因为它不适用于临时和const容器(以及const对象的容器).此外,即使你写的是相反的(实际上,你不能写),现在底层对象将作为参考返回.但我认为这些问题可以通过更多努力和精心设计来解决.毕竟,这只是一个基本想法的示范.auto itemauto & itemauto &item