2

我想为仅从第二次迭代运行的 for 循环创建一个辅助函数，因为我有很多具有以下模式的代码：

firstItem = true;
for (unsigned i = 0; i < 5; ++i)
{
  firstItem ? firstItem = false : std::cout << ",\n";
  std::cout << i;
}

我开始为此考虑一个辅助函数，并提出了这个解决方案：

template <typename T>
void fromSecondIter(T fn)
{
  static bool firstItem = true; // because of this it works with unique types only
  if (firstItem)
    firstItem = false;
  else
    fn();
}

我的问题是，当 T 是唯一类型时，此解决方案可以正常工作。所以传递一个 lambda 是可以的，但是传递一个函数会默默地导致错误。然后我将该 fn 参数包装为 lambda，但令人惊讶的是它没有帮助；

这是一个完整的例子：

#include <type_traits>
#include <iostream>
#include <functional>

template <typename T>
void fromSecondIter(T fn)
{
  static bool firstItem = true;
  if (firstItem)
    firstItem = false;
  else
    fn();
}

template <typename T>
void iterTest(T fn)
{
  std::cout << "Numbers: ";
  for (unsigned i = 0; i < 5; ++i)
  {
    fromSecondIter([&fn](){ fn(); }); // bad, why lambda is not unique here???
    std::cout << i;
  }
  std::cout << std::endl;
}

void foo()
{
  std::cout << ", ";
}

void test()
{
  iterTest([](){ std::cout << ", "; }); // ok, lambda is unique
  iterTest([](){ std::cout << ", "; }); // ok, lambda is unique
  iterTest(foo); // ok
  iterTest(foo); // bad
}

int main()
{
  test();

  return 0;
}

这打印：

Numbers: 0, 1, 2, 3, 4
Numbers: 0, 1, 2, 3, 4
Numbers: 0, 1, 2, 3, 4
Numbers: , 0, 1, 2, 3, 4
4

2 回答 2

5

Lambda 表达式创建唯一类型，但这并不意味着每次执行在代码中通过一个新的唯一类型时都会创建：

int main() {
  for (int i=0; i<3; ++i) {
    [] { std::cout << "Hello, World\n"; }();
  }
}

上面的 for 循环创建了三个相同类型的对象。

在您的代码中，您有一个模板函数 ，iterTest其中包含一个 lambda 表达式。这意味着对于iterTestlambda 表达式的每个实例化都将具有唯一的类型。但是，如果您运行iterTestlambda 表达式的相同实例化，则每次都具有相同的类型。这就是这里发生的事情。

作为示例，这是一种解决方法，对示例代码的更改最少：

template <typename T>
void iterTest(T fn)
{
  std::cout << "Numbers: ";
  for (unsigned i = 0; i < 5; ++i)
  {
    fromSecondIter(fn);
    std::cout << i;
  }
  std::cout << std::endl;
}

void test()
{
  iterTest([](){ std::cout << ", "; }); // ok, lambda is unique
  iterTest([](){ std::cout << ", "; }); // ok, lambda is unique
  iterTest([]{foo();}); // ok
  iterTest([]{foo();}); // also ok
}

您当前的实现fromSecondIter将创建一个静态变量，该变量从创建到程序结束都持续存在，并且将从程序开始时为它保留内存。这不是一个巨大的成本，但有更好的方法；创建一个具有 bool 成员变量的对象，以及具有operator()必要逻辑的成员函数（例如 ）。

#include <iostream>

struct skipper {
  bool first = true;

  template<typename Fn>
  void operator() (Fn &&fn) {
    if (first)
      first = false;
    else
      fn();
  }
};

int main()
{
  skipper skip_first;
  for (int i=0; i<10; ++i) {
    skip_first([]{ std::cout << ", "; });
    std::cout << i;      
  }
}

这意味着使用它需要两行而不是一行，但现在您可以控制范围。

于 2013-10-10T16:14:52.613 回答
1

为每个 lambda 实例化模板函数会创建一个新的函数定义。因为 lambda 函数类型不同（即使它们具有相同的声明）。

所以每个定义都有自己的static firstItem.

但是因为foo只有一个定义，所以static在第一次调用 for 之后会改变foo：

iterTest([](){ std::cout << ", "; }); // iterTest, fromSecondIter for this lambda
iterTest([](){ std::cout << ", "; }); // iterTest, fromSecondIter for this lambda
iterTest(foo);                        // iterTest, fromSecondIter for this foo
iterTest(foo);                        // uses above functions

一个简单的例子来证明这个问题是：

template <int i>
struct foo
{
    void operator()()
    {
        std::cout << ", ";
    }
};


void test()
{
  iterTest([](){ std::cout << ", "; });
  iterTest([](){ std::cout << ", "; });
  iterTest(foo<1>());
  iterTest(foo<2>());
}

foo<1>()并且foo<2>()是不同的类型，所以它会让fromSecondIter他们有两个不同的。然后firstItem不变。

于 2013-10-10T15:57:56.927 回答