Kann ich std :: bind verwenden, um einen Status an eine Funktion anzuhängen?

Question

Ich muss eine std :: -Funktion an einen Algorithmus übergeben. Die Art der Funktion ist

typedef std::function<bool(const double&)> Condition; 

Im einfachsten Fall diese Funktion wie diese

bool simpleCondition(const double& d){return d<0.001;} 

aussehen Nun möchte ich den gleichen Zustand zu übergeben, aber nur dann, wenn die Bedingung mehrere Male erfüllt in eine Zeile, sollte die Funktion wahr zurückgeben. Ich habe folgendes versucht

class RepeatingCondition{ 
    public: 
     static Condition getRepeatingCondition(Condition c,int reps){ 
      return std::bind(&RepeatingCondition::evalCondition, 
            RepeatingCondition(c,reps),_1); 
     } 
    private: 
     RepeatingCondition(Condition cc,int reps) : counter(0), 
               reps(reps),cond(cc){} 
     bool evalCondition(const double& d){ 
      if (cond(d)){counter += 1;} 
      else {counter = 0;} 
      return (counter >= reps); 
     } 
     Condition cond; 
     int counter,reps; 
}; 

Mein Compiler klagen nicht und es scheint zu funktionieren wie erwartet. Allerdings verstehe ich nicht wirklich warum (mit einem einfachen Funktionszeiger würde es nicht funktionieren, oder?). Außerdem würde ich gerne wissen, ob es einen einfacheren Weg gibt, dasselbe zu erreichen.

Answer 1

Kann ich std::bind verwenden, um einen Status an eine Funktion anzuhängen?

Ja, genau dafür ist es da. Sie gibt ein Objekt (eines nicht angegebenen Klassentyps) zurück, das den Funktionszeiger und alle gebundenen Argumente enthält, mit einem Funktionsaufruf operator(), um die Funktion mit diesen Argumenten aufzurufen.

std::function kapselt dann dieses Objekt ein und ermöglicht es, dass es herumgereicht und aufgerufen wird, ohne seinen Typ zu kennen. Diese Technik ist bekannt als Typ Löschung.

mit einem einfachen Funktionszeiger würde es nicht funktionieren, oder?

In der Tat brauchen Sie etwas komplizierter dafür zu arbeiten. Genau das bieten std::bind und std::function.

Auch würde ich gerne wissen, ob es einen einfacheren Weg, um das gleiche zu erreichen ist.

Ein Lambda ist oft besser lesbar als ein Binde Ausdruck:

static Condition getRepeatingCondition(Condition c,int reps){ 
    RepeatingCondition rep(c,reps); 
    return [rep](double d) mutable {return rep.evalCondition(d);}; 
} 

Answer 2

Da @ Mike Seymour bereits die Lambda-Ansatz hat, werde ich eine alternative Verwendung functors vorzuschlagen, die eine gute Alternative sein könnte der Code in der Frage:

class RepeatingCondition { 
    Condition m_condition; 
    int  m_counter, m_reps; 

public: 
    RepeatingCondition(Condition c, int reps) 
    : m_condition(c), m_counter(0) , m_reps(reps) { } 

    bool operator()(const double d) { 
     if(m_codition(d)) { 
      m_counter += 1; 
     } else { 
      m_counter = 0; 
     } 

     return (m_counter >= m_reps); 
    } 
}; 

Jetzt können Sie die Instanz erstellen Sie die RepeatingCondition Klasse verwenden möchten, etwa so:

RepeatingCondition repCond(checkDouble, 12); 

if(repCond(5.4)) { // calls the operator() overload 
    std::cout << "condition met\n"; 
}