Question

前言这个问题：我已经在一个更大的工具包中实现了各种C ++实用程序函数和（当我不得不）我自己使用的宏。最近我一直在制作基于BOOST_FOREACH的各种循环宏以及可迭代的意识函数。

长话短说，我遇到了很难做出一个枚举循环，它使用BOOST_FOREACH但是传递了一个额外的参数，它在循环的每次迭代中递增。这就像Python中的enumerate命令一样，我觉得在循环任意迭代器时很有用，而不需要添加大量的样板代码。宏的形式类似于BOOST_FOREACH：

ENUMERATE_FOREACH(COUNT, VAR, COL)

并且会有效地执行此操作，但不依赖于将不平衡的'}'置于关闭（或其他循环结束宏）：

COUNT = 0; BOOST_FOREACH(VAR, COL) { COUNT++; ...Rest of loop...

在我得到试图在C ++中创建非C ++运算符的指控之前，我完全清楚这是将一个外国概念塞进C ++中，而我并没有尝试使用Pythonize C ++代码。我只是很好奇是否可以完全实现具有已知工具集/ boost的循环而没有极端依赖性。具有这样的宏定义将消除某些循环样式的错误可能来源，我需要在迭代时对其进行计数，并消除COUNT变量的目的。

我考虑过在COL变量进入BOOST_FOREACH之前做一个模板包装器，但是COL的可能性使得一些可迭代变量的组合变得困难/不可能，而没有使用不同版本的ENUMERATE_FOREACH并重新实现了很多BOOST_FOREACH - 一项艰巨而愚蠢的任务，没有大量的测试/时间。

执行一个单独的内联函数可能会有效，但是循环的语法会被破坏，而且我更多的是每个样式的操作符函数传递情况（我已经实现了）。

这让我从boost的库中获取foreach.hpp的最后一行，并在附加参数上插入我自己的increment操作符。然后我成为依赖于升级版本并担心新的更新（任何语法更改），以提高我的hacky自定义宏。

我想到的最后一个选项是执行ENUMERATE_BEGIN和ENUMERATE_END来隐藏我的迭代器增量操作。这种方法比单个宏更容易出错，因为用户必须放置两个宏而不是一个宏 - 尽管这可能是唯一的简单解决方案。

我试着四处寻找SO和其他来源，看看有没有人在没有太多运气的情况下尝试过这个。希望有人成功地使用了这样的实现概念，或者想要改变我的方法。如果没有一种干净的方法，我可以在计数时继续使用count ++开始循环。再一次，这更像是一种好奇心，有人可能会提出我所狡辩的一个想法是一种完全合理的方法，或者它会得到的好。

Answer 1

您可以通过使用ENUMERATE_FOREACH的四参数版本来解决它，其中最后一个参数是要调用的谓词。

类似的东西：

ENUMERATE_FOREACH(COUNT, VAR, COL, PRED)

它会扩展到像

这样的东西

{
    COUNT = 0;
    BOOST_FOREACH(VAR, COL)
    {
        PRED(COUNT);
        COUNT++;
    }
}

上面的好处是谓词可以是C ++ 11 lambda函数：

ENUMERATE_FOREACH(COUNT, VAR, COL,
                  [](int count){ cout << "count = " << count << '\n'; });

编辑：另一种方法是仍然使用第四个参数，但让该参数为实际代码。例如：

ENUMERATE_FOREACH(COUNT, VAR, COL, do { std::cout << COUNT << '\n'; } while (0))

将扩展为

{
    COUNT = 0;
    BOOST_FOREACH(VAR, COL)
    {
        do { std::cout << COUNT << '\n'; } while (0);
        COUNT++;
    }
}

它可能比使用例如C ++ 11 lambdas。

编辑2：如果你有C ++ 11，并且可以使用lambdas，那么你可能也有新的range-based for loop，这意味着你可以创建一个合适的函数，类似的东西：

template<typename SeqT, typename PredT>
void for_each_count(SeqT seq, PredT pred)
{
    int count = 0;
    for (auto val : seq)
    {
        pred(val, count);
        count++;
    }
}

用法：

std::vector<int> v = {1, 2, 3, 4};
for_each_count(v,
    [](int v, int c){
        std::cout << "value = " << v << ", count = " << c << '\n';
    });

以上将打印

value = 1, count = 0
value = 2, count = 1
value = 3, count = 2
value = 4, count = 3

Answer 2

在阅读了Joachim的回复之后我非常满意，但是我试图操纵BOOST_FOREACH，直到我至少能够以一种非常黑客的方式进行操作，然后我发现我可以以良性的方式实现计数器，而无需重写整个宏或在BOOST_FOREACH_NEXT上做一些#undef #define语句。

我滥用了BOOST_FOREACH有一个（VAR = derefence（...）; ...）语句并在VAR和=之间放置一个结构的事实，以便得到（VAR = IncrementCountAndPassRHS = derefence（...） ; ...）。

我还没有对宏扩展问题进行过多次测试，但我认为它在forloop中是安全的。

编辑添加更新以修复同一行中多个循环的变量范围名称重叠问题。

namespace loopnamespace {
template<typename T>
void incrementT(T *t) {
    (*t)++;
}

struct IncrementCounterPassthrough {
    bool checker;
    boost::function<void(void)> incrementer;

    template<typename Count>
    IncrementCounterPassthrough(Count& t) {
        t = -1;
        checker = true;
        incrementer = boost::bind(&incrementT<Count>, &t);
    }

    template<typename T>
    T& operator=(T& rhs) {
        incrementer();
        return rhs;
    }
};
}

#define ENUMERATE_FOREACH(COUNT, VAR, COL)                                                                   \
    for(::loopnamespace::IncrementCounterPassthrough BOOST_FOREACH_ID(_foreach_count_pass)(COUNT);           \
        BOOST_FOREACH_ID(_foreach_count_pass).checker; BOOST_FOREACH_ID(_foreach_count_pass).checker = false)\
    BOOST_FOREACH(VAR = BOOST_FOREACH_ID(_foreach_count_pass), COL)

允许我这样做：

std::string hello( "Hello, boost world!" );
unsigned int value;
ENUMERATE_FOREACH( value, char ch, hello ) {
   std::cout << ch << " => " << value << "\n";
}

输出：

H => 0
e => 1
l => 2
l => 3
o => 4
, => 5
  => 6
b => 7
o => 8
o => 9
s => 10
t => 11
  => 12
w => 13
o => 14
r => 15
l => 16
d => 17
! => 18

基于Boost foreach实现enumerate_foreach

2 个答案: