Boost-Funktion und boost bind: Binden Sie den Rückgabewert?

Dies ist im Zusammenhang mit dieser vorhergehenden Frage: Mit boost::bind, boost::function: abrufen der gebundenen variable Typ.

Kann ich binden, eine Funktion wie diese:

in .h:

class MyClass
{
    void foo(int a);
    void bar();
    void execute(char* param);
    int _myint;
}

in .cpp

MyClass::bar()
{
    vector<boost::function<void(void)> myVector;
    myVector.push_back(boost::bind(&MyClass::foo, this, MyClass::_myint);
}
MyClass::execute(char* param)
{
    boost::function<void(void)> f  = myVector[0];
    _myint = atoi(param);
    f();
}

Aber wie kann ich binden einen Wert zurück ? also:

in .h:

class MyClass
{
    double foo(int a);
    void bar();
    void execute(char* param);
    int _myint;
    double _mydouble;
}

in .cpp

MyClass::bar()
{
    vector<boost::function<void(void)> myVector;
    //PROBLEM IS HERE: HOW DO I BIND "_mydouble"
    myVector.push_back(boost::bind<double>(&MyClass::foo, this, MyClass::_myint);
}
MyClass::execute(char* param)
{
    double returnval;
    boost::function<void(void)> f  = myVector[0];
    _myint = atoi(param);
    //THIS DOES NOT WORK: cannot convert 'void' to 'double'
    //returnval = f();
    //MAYBE THIS WOULD IF I COULD BIND...:
    //returnval = _mydouble;

}
  • Sie haben eine function<void(void)> -- wo erwarten Sie ein double zu kommen, in diese überhaupt? Wenn Sie möchten, eine nullary function<> gibt eine double versuchen function<double()>...
  • Blick auf die Letzte Zeile des bar Funktion, das ist wie das input-argument gebunden ist, die Funktion Typ ist gelöscht und wird function<void(void>> aber _myint ist noch verlinkt.. ich will das gleiche für den Rückgabewert. Der Punkt ist, um in der Lage zu speichern, die boost::Funktionen in den gleichen Vektor 😉
  • Aber Sie haben ausdrücklich angegeben, dass Sie wollen void als Rückgabewert (function<void(void)>); entweder Sie wollen void oder möchten Sie double Sie können nicht beides haben.
  • Ich Stimme zu, dass returnval = f(); nicht funktionieren sollte, aber es sollte ein Weg gefunden werden, binden Sie den Rückgabewert, so wie es auch eine Möglichkeit zum binden der input-Wert...
  • Nein, Zu Steigern.Binden bindet Funktionen und Parameter. Die Ausführung der Funktion und der resultierende Rückgabe eines Wertes ist genau das gleiche wie wenn Sie aufgerufen, eine reguläre Funktion.
InformationsquelleAutor Smash | 2011-10-31
  1. 6

    Wenn das, was Sie wollen, ist eine nullary Funktion zurückgibt, die void sondern weist einen Wert zu _myDouble mit dem Ergebnis foo() bevor Sie dies tun, dann können Sie dies leicht tun mit nur Boost.Binden. Aber Boost ist eine Bibliothek, die speziell kümmerten sich um diese Art der Sache -- Boost.Phoenix:

    #include <iostream>
#include <vector>
#include <boost/function.hpp>
#include <boost/phoenix/phoenix.hpp>

struct MyClass
{
    MyClass() : _myVector(), _myInt(), _myDouble() { }
    void setMyInt(int i);
    void bar();
    void execute();

private:
    double foo(int const a) { return a * 2.; }

    std::vector<boost::function<void()> > _myVector;
    int _myInt;
    double _myDouble;
};

void MyClass::setMyInt(int const i)
{
    _myInt = i;
}

void MyClass::bar()
{
    using boost::phoenix::bind;

    _myVector.push_back(
        bind(&MyClass::_myDouble, this) =
            bind(&MyClass::foo, this, bind(&MyClass::_myInt, this))
    );
}

void MyClass::execute()
{
    if (_myVector.empty())
        return;

    _myVector.back()();
    double const returnval = _myDouble;
    std::cout << returnval << '\n';
}

int main()
{
    MyClass mc;
    mc.bar();

    mc.setMyInt(21);
    mc.execute();      //prints 42
    mc.setMyInt(3);
    mc.execute();      //prints 6  (using the same bound function!)
                       //i.e., bar has still only been called once and
                       //_myVector still contains only a single element;
                       //only mc._myInt was modified
}
    • das sieht interessant und genau das was ich brauche, ich werde es morgen testen, danke
    • ah, ich habe gerade auch eine motivation zu lernen, phoenix. Coole Sachen
    InformationsquelleAutor ildjarn
  2. 1

    problem 1: myVector werden muss, um eine Klasse Mitglied.
    problem 2: myVector interessiert-Funktionen, die Rückkehr verdoppelt und nehmen keine Argumente, das wäre boost::function<double()>

    dann, zu binden _mydouble, um die parameter von foo, rufen Sie boost::bind(&MyClass::foo, this, MyClass::_mydouble) die Ihnen zu einer Compilerwarnung über die Umwandlung eines double in einen int, wenn foo aufgerufen wird.

    Die nächstgelegene Sie kommen können, mit Boost.Binden, ist die Bereitstellung der toreturn als parameter. 

    #include <iostream>
#include <boost/bind.hpp>
#include <boost/function.hpp>

using namespace std;

class Foo {
        int myInt;
        double myDouble;
public:
        Foo() : myInt(3), myDouble(3.141592) { }
        void SetToMyInt(double& param)
        {
                param = myInt;
        }
        void SetToMyDouble(double& param)
        {
                param = myDouble;
        }
        double Execute()
        {
                double toReturn = 2;
                boost::function<void(double&)> f = boost::bind(&Foo::SetToMyDouble, this, _1);
                f(toReturn);
                return toReturn;
        }

};

int main() {
        Foo foo;
        std::cout << foo.Execute() << std::endl;
        return 0;
}
    • boost::function<double(void)> Bitte nicht weitergeben diese hässlichen C-ism, lieber boost::function<double()>.
    • Sicher, nur wiederholt sich das Muster der boost-docs.
    • Fair genug :-]
    • 1: myVector natürlich eine Klasse 😛 und zu sehen, Kommentare zu warum ist es interessiert <void(void)> Funktionen
    • Nein, es ist nicht offensichtlich. Kochen Sie Ihren code unten auf etwas, das Exponate dein problem mit einem tool wie ideone.com und DANN poste deinen code.
    InformationsquelleAutor totowtwo
Schreibe einen Kommentar