3

作为这个问题的序言：我一直在一个更大的工具包中实现各种 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++ 代码。我只是好奇是否完全可以使用已知的工具集/提升来实现这样的循环而没有极端依赖。拥有这样的宏定义将消除某些循环样式的错误来源，在这些样式中我需要在迭代时进行计数，并且它消除了 COUNT 变量的用途的歧义。

我考虑过在 COL 变量进入 BOOST_FOREACH 之前对其进行模板包装，但是 COL 的可能性数量使得在不制作不同版本的 ENUMERATE_FOREACH 并重新实现大量 BOOST_FOREACH 的情况下，使用一些可迭代变量的组合变得困难/不可能 - - 没有大量测试/时间的艰巨和愚蠢的任务。

做一个单独的内联函数可能会起作用，但是循环的语法会被破坏，我会遇到更多的 on-each 风格的运算符函数传递情况（我已经实现了）。

这让我不得不从 boost 的库中获取 foreach.hpp 的最后几行，并在附加参数上插入我自己的增量运算符。然后我变得依赖于 boost 版本，并担心新的更新（任何语法更改）会破坏我的 hacky 自定义宏。

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

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

4

2 回答 2

4

您可以通过使用 的四参数版本来解决它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，并且可以使用 lambda，那么您可能也有新的基于范围的 for 循环，这意味着您可以创建一个适当的函数，例如：

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

以上将打印

值 = 1，计数 = 0
值 = 2，计数 = 1
值 = 3，计数 = 2
值 = 4，计数 = 3
于 2012-07-31T05:16:20.723 回答
1

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

我滥用了 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
于 2012-07-31T21:13:31.703 回答