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_iterator。

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

基于Lambda的将向量分割为多个较小向量的STL算法

1 个答案: