Boost::Thread und member-Funktionen

314159265358979

rofl

D3lta

Was sind denn Placeholders?
Und wie kann ich meiner Funktion Argumente übergeben?

mfg D3lta

314159265358979

gnihihi

D3lta

314159265358979 schrieb:

gnihihi

Was ist?

mfg D3lta

@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?

D3lta

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

@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

Warum so kompliziert? Wenn die Klasse ein "callable" Interface anbietet, sprich: operator() überlädt, reich boost::thread doch this, zumindest laut boost Dokumentation. Oder übersehe ich da was?

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

krümelkacker

Ich weiß jetzt nicht, wie es bei Boost aussieht, aber ein std::thread darf man nicht einfach erzeugen und wieder zerstören ohne .join oder .detatch (falls es das noch gibt) aufgerufen zu haben.

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)

314159265358979 schrieb:

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

314159265358979

pi_herausforderer schrieb:

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

Die Fehlermeldungen sind ekelhaft.

pumuckl

ogni42 schrieb:

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

krümelkacker

kopfschüttler schrieb:

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.