Question

假设我有一个多边形矢量，其中每个多边形包含一个点矢量。我必须在我的代码中多次迭代所有多边形的所有点，我最终不得不一遍又一遍地编写相同的代码：

for(std::vector<Polygon*>::const_iterator polygon = polygons.begin();
                polygon != polygons.end(); polygon++)
{
        for(std::vector<Point>::const_iterator point = (*polygon)->points.begin();
                        point != (*polygon)->points.end(); point++)
        {
                (*point).DoSomething();
        }
}

我真的觉得这是两个简单迭代的很多代码，感觉它堵塞了代码并干扰了可读性。

我认为有些选择：

使用#defines - 但它会使得不可移植（在代码的其他部分使用）。此外，现在认为#defines是邪恶的;
迭代vector-＆gt; size（） - 它似乎不是最优雅的方式;
使用函数指针调用方法 - 但在这种情况下，应该在循环内部的代码远离循环。

那么，这样做最干净，最优雅的方式是什么？

Answer 1

在C ++ 11中，使用ranged-base for loops和auto关键字：

for(const auto& polygon : polygons) {
    for(const auto& point : polygon->points) {
        point.DoSomething();
    }
}

Answer 2

如果您不能使用C ++ 11，则boost会有一个FOREACH宏，它会生成大量代码但会大大简化您的代码：

BOOST_FOREACH(Polygon * polygon, polygons)
{
    BOOST_FOREACH( Point & point, polygon->points )
    {
        point.doSomething();
    }
}

Answer 3

可以使用以下算法重写内部循环：

std::for_each(
    (*polygon)->points.begin(), (*polygon)->points.end(), 
    &Point::DoSomething
);

将它与外循环混合有点复杂：

std::for_each(
    polygons.begin(), polygons.end(),
    []( Polygon* polygon ) {
        std::for_each(
            polygon->points.begin(), polygon->points.end(), 
            &Point::DoSomething
        );
    }
);

如果我们有某种复合迭代器，我们可以真正表达你的意图，即为每个多边形中的每个点做 。并且范围库（如 Boost.Range ）允许您避免将每个容器命名两次，因为您希望使用整个范围。

我理想的代码版本如下所示：

for_each( flatten( polygons ), &Point::DoSomething );

flatten会在每个Point中返回每个Polygon的视图，就像它是一个连续的范围一样。请注意，这是可以在简单的 C ++ 03 中完成的，而我们在 Boost.Range 中缺少的所有内容都是 flatenning range < / em>，在范围join方面应该难以实现。

否则，基于范围的for循环和auto将帮助您减少迭代抛出范围并忘记复杂类型的样板。

Answer 4

如果你不能使用C ++ 11，也许可以将迭代器类型定义为更短的类似

typedef std::vector<Polygon*>::const_iterator PolyCit;
for (PolyCit polygon = polygons.begin(); polygon != polygons.end(); polygon++)

Answer 5

没关系，这对你不起作用，因为你在顶层有一个指针向量，但我会保持它，因为我认为这很酷。

我的模板元编程有点生疏，所以可能有一种更简单的方法，但是：

template<typename C, typename F, size_t depth>
struct nested_for_each_helper
{
    static void do_it(C& c, F& f)
    {
        for (auto& i : c)
            nested_for_each_helper<decltype(i),F,depth-1>::do_it(i,f);
    }
};

template<typename C, typename F>
struct nested_for_each_helper<C,F,0>
{
    static void do_it(C& c, F& f)
    {
        f(c);
    }
};

template<size_t depth, typename C, typename F>
void nested_for_each(C& c, F& f)
{
    nested_for_each_helper<C,F,depth>::do_it(c,f);
}

int main()
{        
    int n[3][3][3][3];
    int i = 0;
    nested_for_each<4>(n,[&i](int& n) { n = i++; });
    nested_for_each<4>(n,[](int n){
        std::cout << n << ' ';
    });
}

对于您的情况，您可以像这样使用它（不，你不能）：

nested_for_each<2>(polygons, [](Point const& p) { p.DoSomething(); });

Answer 6

你需要一层抽象。不要处理多边形向量，而是编写一个管理该向量的类。然后，该类提供迭代器对以迭代点。迭代器中的代码知道并封装了这些细节。

Answer 7

首先，有一个普通的基于整数的循环。比迭代器短一点。

for( int i = 0 ; i < polygons.size() ; i++ )
{
    for( int j = 0 ; j < polygons[i]->points.size(); j++)
    {
        Point* p = polygons[i]->points[j] ;
        p->DoSomething();
    }
}

如果您不喜欢它，并且您没有可用的C ++ 11，您可以编写接受仿函数的函数（这些函数位于std::tr1下的C ++ 0x中我相信）：< / p>

void eachPoint( function<void (Point* p)> func )
{
    for( int i = 0 ; i < polygons.size() ; i++ )
    {
        for( int j = 0 ; j < polygons[i]->points.size(); j++)
        {
            Point* p = polygons[i]->points[j] ;
            func(p);
        }
    }
}

或者，一个普通的旧宏：

#define EACH_POLYGON( polyCollection ) for( int _polyI = 0 ; _polyI < polyCollection.size() ; _polyI++ ) \
for( int _ptNo = 0, Point* p=polyCollection[_polyI]->points[0] ; j < polyCollection[_polyI]->points.size() && (p=polyCollection[_polyI]->points[_ptNo]); _ptNo++)

EACH_POLYGON( polyCollection )
{
    p->DoSomething();
}

在C ++中迭代的优雅方式

7 个答案: