10

我想使用remove_if函数从向量中删除元素，但将擦除限制为 N 个元素。

例子：

// predicate function that determines if a value is an odd number.
bool IsOdd (int i) {

  if (we deleted more than deleteLimit)
    return false;

  return ((i%2)==1);
}


void otherFunc(){
  int deleteLimit = 10;

  // remove odd numbers:                       
  std::vector<int>::iterator newEnd =
  std::remove_if (myints.begin(), myints.end(), IsOdd (how to pass deleteLimit?) );
}

我需要该IsOdd谓词存储它已删除的元素数量以及我们要删除的元素数量。唯一的方法是使用全局变量吗？像这样：

int deleteLimit = 10;
int removedSoFar = 0;
bool IsOdd (int i) {

  if (deleteLimit < removedSoFar)
    return false;

  if (i%2==1) {
    removedSoFar++
    return true;
  }

  return false;

}
remove_if ...
4

5 回答 5

14

告诉“到目前为止已经删除了多少元素”的状态应该在函数/对算法的调用之外定义。这是因为仿函数不应该具有在被调用时被修改的状态（这将是未定义的行为）。

您应该在仿函数的构造函数中引用此状态（计数器）（或在 lambda 中通过引用捕获），以便您可以访问和修改此计数器。现在复制这个函子时，算法调用哪个函子并不重要，因为它们现在都持有对同一个 state的引用。

使用函子 (C++03)：

class IsOdd {
    int deleteLimit;
    int & deletedSoFar;

public:
    IsOdd(int deleteLimit, int & deletedSoFar) :
        deleteLimit(deleteLimit), deletedSoFar(deletedSoFar)
    {}

    bool operator()(int i) const {
        if (deletedSoFar < deleteLimit && i % 2) {
            ++deletedSoFar;
            return true;
        }
        return false;
    }
};

int deletedSoFar = 0;
int deleteLimit = 10;
std::remove_if (myints.begin(), myints.end(), IsOdd(deleteLimit, deletedSoFar));

使用 lambda (C++11)：

int deletedSoFar = 0;
int deleteLimit = 10;
auto it = std::remove_if (myints.begin(), myints.end(), [deleteLimit,&deletedSoFar](int i){
    if (deletedSoFar < deleteLimit && i % 2) {
        ++deletedSoFar;
        return true;
    }
    return false;
});
myints.erase(it, myints.end());
于 2013-06-04T11:10:31.433 回答
6

除了创建自己的仿函数之外，您还可以传递 lambda 表达式：

auto deleteLimit = 25;
auto removedSoFar = 0;
auto it = remove_if (myints.begin(), 
                     myints.end(), 
                     [deleteLimit, &removedSoFar](int i)->bool 
                     { 
                       if ( (deletedSoFar < deleteLimit) && (i % 2)) {
                          ++deletedSoFar;
                          return true;
                       }
                       return false;
                      } );

// really remove the elements from the container
myints.erase(it, myints.end());

但是，请注意有状态函子和标准库算法并不总是很好的混合。在这里，对 lambda 的调用可能会产生副作用，因此您无法保证将删除序列中的哪些元素。

注意最后调用std::vector::erase. 这是真正从容器中删除不需要的元素所必需的。请参阅擦除删除成语。

于 2013-06-04T10:45:55.493 回答
2

投票答案中的代码有一个小错误。在 operator 关键字之前缺少括号。我无法进行编辑，因为它少于六个字符，我无法发表评论，因为我的分数太低了。

class IsOdd {
        int deleteLimit;
        int & deletedSoFar;

    public:
        IsOdd(int deleteLimit, int & deletedSoFar) :
            deleteLimit(deleteLimit), deletedSoFar(deletedSoFar)
        {}

        bool operator()(int i) const {
            if (deletedSoFar < deleteLimit && i % 2) {
                ++deletedSoFar;
                return true;
            }
            return false;
        }
    };

    int deletedSoFar = 0;
    int deleteLimit = 10;
    std::remove_if (myints.begin(), myints.end(), IsOdd(deleteLimit, deletedSoFar));
于 2013-07-30T09:23:06.460 回答
2

使用functor, 构造operator (), 或使用一些绑定特性 (std::bind/boost::bind)。

bool isOdd(int current, int limit, int& count)
{
   if (count >= limit)
   {
      return false;
   }
   if (current % 2 == 1)
   {
      ++count;
      return true;
   }
   return false;
}

int count = 0, limit = 10;
vec.erase(std::remove_if(vec.begin(), vec.end(),
std::bind(&isOdd, _1, limit, std::ref(count)), vec.end());

和函子

struct IsOdd : public std::unary_function<int, bool>
{
public:
   IsOdd(int l) : count(0), limit(l)
   {
   }
   bool operator () (int i)
   {
      if (count >= limit)
      {
         return false;
      }
      if (current % 2 == 1)
      {
         ++count;
         return true;
      }
      return false;
private:
   int count;
   int limit;
};

int limit = 10;
vec.erase(std::remove_if(vec.begin(), vec.end(),
isOdd(limit)), vec.end());
于 2013-06-04T10:40:13.637 回答
2 
int initial_size = myints.size();
std::remove_if (myints.begin(), myints.end(), [myints.size(),limit,initial_size](int i)->bool{  
return ( ( initial_size-myints.size() )<limit ? i%2 : false) } );
于 2013-06-04T10:53:24.813 回答