Übergeben Sie zusätzliche Argumente zu remove_if

Question

Ich möchte Elemente aus einem Vektor mit remove_if Funktion entfernen, aber das Löschen auf N Elemente beschränken.

Beispiel:

// 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?)); 
} 

Ich brauche das IsOdd Prädikat speichert, wie viele Elemente es entfernt und wie viele wir wollen löschen. Die einzige Möglichkeit besteht darin, eine globale Variable zu verwenden? Wie folgt aus:

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 ... 

Answer 1

Der Status "Wie viele Elemente wurden bisher entfernt" sollte außerhalb der Funktion/des Aufrufs des Algorithmus definiert werden. Dies liegt daran, dass ein Funktor keinen Zustand haben sollte, der beim Aufruf geändert wird (dies wäre ein undefiniertes Verhalten).

Sie sollten einen Verweis auf diesen Status (Zähler) im Konstruktor des Funktors nehmen (oder durch Referenz im Lambda erfassen), so dass Sie auf diesen Zähler zugreifen und diesen ändern können. Wenn dieser Funktor jetzt kopiert wird, ist es egal, welcher vom Algorithmus aufgerufen wird, da alle von ihnen jetzt den Bezug auf den gleichen Zustand haben.

Mit functors (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)); 

Mit 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()); 

Answer 2

Verwenden functor, Struktur mit operator() oder benutze binden Features (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()); 

Und mit Funktors

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()); 

Answer 3

Neben Ihren eigenen Funktor erstellen, können Sie einen Lambda-Ausdruck übergeben:

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()); 

jedoch aufpassen, dass stateful functors and std library algorithms are not always good mix. Hier können Aufrufe an den Lambda einen Nebeneffekt haben, also haben Sie keine Garantie über welche Elemente in der Sequenz entfernt werden.

Beachten Sie den letzten Anruf an std::vector::erase. Dies ist erforderlich, um die unerwünschten Elemente wirklich aus dem Container zu entfernen. Siehe erase remove idiom.

Answer 4

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) }); 

Answer 5

Der Code in der Antwort gestimmt up hat eine kleine Fehler. Es fehlen Klammern vor dem Operator-Schlüsselwort. Ich konnte die Bearbeitung nicht mit weniger als sechs Zeichen durchführen und konnte nicht kommentieren, da meine Punktzahl zu niedrig ist.

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));