用于基于lambda将矢量分割成多个较小的矢量的STL算法

Question

假设我有一个包含结构的向量，其中一个成员描述了它的目标向量。

struct Foo
{
  int target;
  static const int A = 0;
  static const int B = 1;
  static const int C = 2;
};

std::vector<Foo> elements;

std::vector<Foo> As;
std::vector<Foo> Bs;
std::vector<Foo> Cs;
std::vector<Foo> others;

现在我想根据Target的值将每个Foo移动到其他四个向量中的一个中。

例如

auto elements = std::vector<Foo>{ {Foo::A}, {Foo::A}, {Foo::B} };

应该在As中产生两个元素，一个在Bs，而在Cs或others中没有。之后Elements应该是空的。

我也可以自己做，但我想知道是否有一个STL算法我可以用来完成它的工作。

Answer 1

标准算法通常不在多个输出目的地上运行，因此当您想通过输出迭代器抽象出目标容器时，很难找到合适的解决方案。可能最接近的是std::copy_if。这看起来像

// Help predicate creation:
auto pred = [](int target){ return [target](const Foo& f){ return f.target == target; }; };

std::copy_if(elements.begin(), elements.end(), std::back_inserter(As), pred(Foo::A));
std::copy_if(elements.begin(), elements.end(), std::back_inserter(Bs), pred(Foo::B));
std::copy_if(elements.begin(), elements.end(), std::back_inserter(Cs), pred(Foo::C));
std::copy_if(elements.begin(), elements.end(), std::back_inserter(others),
    [](const Foo& f){ return false; /* TODO */ });

elements.clear();

如果复制比移动构造更昂贵，你应该将std::make_move_iterator(elements.begin())和elements.end()相同的算法传递给算法。这里的问题是这不会扩展。 std::copy_if线性遍历输入范围，以上必须执行此操作四次。可以获得一次遍历，例如如下。

auto doTheWork = [&As, &Bs, &Cs, &others](const Foo& foo) {
   if (foo.target == Foo::A)
      As.push_back(foo);
   else if (foo.target == Foo::B)
      Bs.push_back(foo);
   else if (foo.target == Foo::C)
      Cs.push_back(foo);
   else
      others.push_back(foo);
};

std::for_each(elements.begin(), elements.end(), doTheWork);

在这种情况下，我们至少采用了标准算法，但将逻辑转换为相当丑陋的lambda。请注意，上面的lambda将始终复制其参数，需要进行一些调整才能正确使用std::move_iterators。

有时，基于循环的良好旧范围是最可读的解决方案。