#include <boost/thread/thread.hpp>

class A
{
public:
        void funcA()
        {
                boost::thread th(funcB);
        }
        void funcB()
        {
                //...
        }
};

int main()
{
        A a;
        a.funcA();
        return 0;
}

Ich habe etwas im Internet Recherchiert und herausgefunden, dass das nur mit statischen Funktionen geht:

#include <boost/thread/thread.hpp>

class A
{
public:
        void funcA()
        {
                boost::thread th(funcB);
        }
        static void funcB()
        {
                //...
        }
};

int main()
{
        A a;
        a.funcA();
        return 0;
}

Aber bei statischen Funktionen gibt es ja logischerweise keinen this-Zeiger.
Wie löst man nun folgendes Problem?

#include <boost/thread/thread.hpp>

class A
{
private:
        int i;
public:
        void funcA()
        {
                i=1;
                boost::thread th(funcB);
        }
        void funcB()
        {
                i++;
        }
};

int main()
{
        A a;
        a.funcA();
        return 0;
}

mfg D3lta

boost::thread t([this] () { funcB(); });

Wenn nicht, dann boost::bind.

Wenn du C++11 hast, würde ich eine Lambda nehmen:

boost::thread t([this] () { funcB(); });

Wenn nicht, dann boost::bind.

Ich sollte die aktuelle Version vom g++ haben, könntest du vielleicht ein Beispiel machen?

mfg D3lta

Wenn du C++11 hast, würde ich eine Lambda nehmen

Manche Anwendungen von Lambdas sollte man bleiben lassen.
Dies ist ein klarer Fall für std::bind(&A::funcB, this) .

314159265358979 schrieb:

Wenn du C++11 hast, würde ich eine Lambda nehmen

Manche Anwendungen von Lambdas sollte man bleiben lassen.
Dies ist ein klarer Fall für std::bind(&A::funcB, this) .

Danke für die Antwort, jetzt sollte es funktionieren

mfg D3lta

P.S.: Es muss boost::bind() heißen.

Insbesondere, wenn dann die placeholders ins Spiel kommen**, ist bind massiv lesbarer**.

FTFY.
Sobald das Lambda Parameter entgegen nimmt hat hat die Lesbarkeit verloren. Dann ist bind kürzer, besser lesbar und weniger fehleranfällig. Nur weil du es nicht verstanden hast, muss es nicht schlecht sein.

PS: std::bind ist C++11, wie die Lambdas.

mfg D3lta

gnihihi

Was ist?

mfg D3lta

struct S { bool foo(const char *str, int arg) { return std::cout << str << ": " << arg << '\n'; } } s;

  boost::bind(&S::foo, s, _1, 5)("hallo");
  [&s] (const char *str) -> bool { return s.foo(str, 5); } ("hallo");

@D3lta: Einfach bind einen weiteren Parameter übergeben?

@pi: Was ist da wohl schöner?

struct S { bool foo(const char *str, int arg) { return std::cout << str << ": " << arg << '\n'; } } s;

  boost::bind(&S::foo, s, _1, 5)("hallo");
  [&s] (const char *str) -> bool { return s.foo(str, 5); } ("hallo");

@D3lta: Einfach bind einen weiteren Parameter übergeben?

Bin für das erste
Aber auch nur, weil ich von Lambda keine Ahnung habe
Fehlt nur noch, dass jemand mir erklärt was Placeholders sind

mfg D3lta

#include <boost/thread/thread.hpp>

class A
{
private:
        int i;
public:
        void funcA()
        {
                i=1;
                boost::thread th(*this, 42, "Hello");
        }
        void operator()(int i, string j)
        {
                i++;
        }
};

int main()
{
        A a;
        a.funcA();
        return 0;
}

Und die std::thread akzeptiert sogar Memberfunktionszeiger:

class foo {
public:
  void bar(double);
};

int main() {
  foo f;
  std::thread t (&foo::bar,&f,2.71828);
  t.join();
}

(ungetestet)

oder man schreibt gleich

class foo {
public:
  void bar(double);
};

int main() {
  foo f;
  auto futr = std::async(&foo::bar,&f,2.71828);
  futr.get();
}

(ungetestet)

Sobald du Placeholder verwendest, wirst du bereuhen, bind verwendet zu haben. Versprochen.

Belege? (Interessiert micht wirklich, ich hab schon einiges mit placeholder gemacht)

Einfach nur den Leuten kurze Phrasen an den Kopf zu werfen, erhöht zwar deinen Post Count, lässt dich aber nicht erfahrener wirken

@Topic:

Auch boost::thread lässt sich mittlerweile ohne bind konstruieren: http://www.boost.org/doc/libs/1_47_0/doc/html/thread/thread_management.html#thread.thread_management.thread.callable_constructor

Belege? (Interessiert micht wirklich, ich hab schon einiges mit placeholder gemacht)

Die Fehlermeldungen sind ekelhaft.

Oder übersehe ich da was?

Ja, du übersiehst, dass das Argument kopiert wird, d.h. du übergibst eine Kopie von *this an den Thread, was nicht ist, was der OP möchte.

@ Lambdas vs. bind: keins von beidem sondern tatsächlich den variadic Konstruktor von std::thread nutzen.

kopfschüttler schrieb:

@pi: Was ist da wohl schöner?

struct S { bool foo(const char *str, int arg) { return std::cout << str << ": " << arg << '\n'; } } s;

  boost::bind(&S::foo, s, _1, 5)("hallo");
  [&s] (const char *str) -> bool { return s.foo(str, 5); } ("hallo");

In dem Fall das lambda, nur ohne den überflüssigen trailing returntype:

auto func = [&s](char const* str) {return s.foo(str,5);};
func("hallo");

Dies ist ein klarer Fall für std::bind(&A::funcB, this) .

Das sehe ich nicht so. Was soll denn an

std::bind(&A::funcB, this)

viel besser sein als bei

[this]{funcB();}

?

Das Blöde bei dem Funktionszeigern ist noch, dass das nicht so schön funktioniert, wenn die Funktionen überladen sind. Mit Einzug von Move Semantics ist schon so mancher Elementfunktionszeiger-verwendender C++ Code kaputt gegangen, weil plötzlich so'was wie push_back überladen ist. Da ist das mit den Lambdas dagegen (zumindest in diesem Fall) eher schmerzfrei.

Außerdem, wenn du schon std::bind verwendest, kannst Du auch gleich den variadischen Konstruktor von std::thread ausnutzen. Dadurch wird ein bind auch überflüssig und es werden sogar move-only-Parameter korrekt unterstützt.