Question

我经常发现自己正在使用一些STL容器，并希望根据某些外部条件对其进行修改。在外部，我的意思是不能仅从容器中的对象派生出来的东西。

例如，假设我已根据一些不仅涉及元素本身的精细标准，确定了我想要保留的容器的哪些元素。保留标志存储在与原始容器大小相同的容器中。现在我想使用std :: remove_if删除标志为零的那些。我怎么能这样做？

std::vector<Foo> container_of_foos;
std::vector<int> to_keep(container_of_foos.size(), 0); 
// ... code calculates which foos to keep and stores a flag for each one
// NOTE: the condition relies information external to the Foo class (could be relation to other Foo instances)
auto i_new_end = std::remove_if(begin(container_of_foos), end(container_of_foos), [&to_keep](const Foo& foo) {
    // can't tell whether to keep, because I don't know which object is iterated now
});

Answer 1

使用boost::zip_iterator

对一组元组迭代器的

boost::zip_iterator确实简化了删除。

std::vector<int> numbers = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
std::vector<bool> selectors = {0, 1, 0, 1, 0, 1, 0, 1, 0, 1};

auto zip_first = boost::make_zip_iterator(
    boost::make_tuple(selectors.begin(), numbers.begin()));
auto zip_last = zip_first + std::min(selectors.size(), numbers.size());

auto removed_first = std::remove_if(zip_first, zip_last, [](const auto& tup) {
  return boost::get<0>(tup) == 0;
});

Live example on Wandbox.

使用算法（非提升）

编写自己的remove / remove_if，它包含两个范围（值和选择器）和一个值/谓词。您必须决定如何处理不匹配的距离。一旦有两个范围处于预期状态，就可以通过擦除来运行压缩。下面是压缩使用另一个范围过滤的范围的示例，以最短的序列终止。

按值和谓词删除

template <typename FwdIt1, typename FwdIt2, typename ValueType>
auto remove(FwdIt1 first1, FwdIt1 last1, FwdIt2 first2, FwdIt2 last2,
            const ValueType value) {
  FwdIt1 curr1 = first1;
  FwdIt2 curr2 = first2;

  for (; curr1 != last1 && curr2 != last2; ++curr1, ++curr2) {
    if (value != *curr2) {
      *first1++ = std::move(*curr1);
      *first2++ = std::move(*curr2);
    }
  }
  return std::make_pair(first1, first2);
}

template <typename FwdIt1, typename FwdIt2, typename Predicate>
auto remove_if(FwdIt1 first1, FwdIt1 last1, FwdIt2 first2, FwdIt2 last2,
               Predicate pred) {
  FwdIt1 curr1 = first1;
  FwdIt2 curr2 = first2;

  for (; curr1 != last1 && curr2 != last2; ++curr1, ++curr2) {
    if (!pred(*curr2)) {
      *first1++ = std::move(*curr1);
      *first2++ = std::move(*curr2);
    }
  }
  return std::make_pair(first1, first2);
}

基于容器的压缩（删除和删除）帮助

template <typename Container, typename Selector, typename ValueType>
auto compress(Container& values, Selector& selectors, const ValueType& value) {
  const auto remove_iters =
      remove(std::begin(values), std::end(values), std::begin(selectors),
             std::end(selectors), value);
  return std::make_pair(
      values.erase(remove_iters.first, std::end(values)),
      selectors.erase(remove_iters.second, std::end(selectors)));
}

template <typename Container, typename Selector, typename Predicate>
auto compress_if(Container& values, Selector& selectors, Predicate pred) {
  const auto remove_iters =
      remove_if(std::begin(values), std::end(values), std::begin(selectors),
                std::end(selectors), pred);
  return std::make_pair(
      values.erase(remove_iters.first, std::end(values)),
      selectors.erase(remove_iters.second, std::end(selectors)));
}

Live Example on Wandbox.

Answer 2

在C ++ 11中，使用lambda作为谓词。例如;

void func()
{
     std::vector<int> container;

      // populate container
     int flag = 42;

      //  modify flag as needed

      auto lambda = [flag](int element) {return element < flag;}  // whatever

     std::remove_if(container.begin(), container.end(), lambda);
}

在C ++ 11之前，使用仿函数。

struct remover
{
     int flag;
     remover(int flag_value) : flag(flag_value) {};

     bool operator()(int element) {return element < flag;};
};

void func()
{
     std::vector<int> container;

      // populate container
     int flag = 42;

      //  modify flag as needed


     remover functor(flag);

     std::remove_if(container.begin(), container.end(), functor);
}

这两个样本基本相同。

在C ++ 11中，查找lambda捕获规范以了解如何将其他变量传递给lambda。在此之前，更改仿函数，以便使用所需的任何变量构造它。

Answer 3

&x-vec.data()是x中vec的索引。

当然，假设x位于vec：否则为UB。

使用外部条件修改序列操作

3 个答案: