STL算法将矢量分解为基于lambda的多个较小的算法

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;

现在，我想根据目标的值将每个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。

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