void bla() {}
int main()
{
	boost::thread asd(&bla);
}

Hier ist ja alles in Ordnung. Aber jetzt will ich den Thread in einem anderen Gültigkeits bereich starten:

void bla() {}
void blaexe (boost::thread &asd) { // Hier soll der Thread gestartet werden }
int main()
{
boost::thread bla(); // Hier noch nicht
blaexe();
// Hier dann sonstiger Kram
}

Wie kann ich jetzt den Thread starten ohne ihn beim erstellen der Instanz zu übergeben???

Hier der Link: http://boost.org/doc/html/thread.html

mfg.

Ich frage mich gerade wozu bei der Thread Klasse von der Boost Library ein Konstruktor exitiert, bei dem man keine Funktion übergibt.

boost Doku schrieb:

Effects: Constructs a thread object representing the current thread of execution.

Wie kann ich jetzt den Thread starten ohne ihn beim erstellen der Instanz zu übergeben???

Indem Du ihn erst dann anlegst, wenn Du ihn brauchst. Damit nicht vorschnell der Destruktor des Threads aufgerufen wird, packst Du ihn am besten in eine Klasse oder Struct.

void bla() {}
struct blaexe
{ 
    blaexe()
        : m_thrd( &bla ) // Hier wird der Thread gestartet
    {}
private:
    boost::thread m_thrd;
};
int main()
{
    blaexe einBlaexe;
    // Hier dann sonstiger Kram
}

irgendwie so

Gruß
Werner

Indem Du ihn erst dann anlegst, wenn Du ihn brauchst. Damit nicht vorschnell der Destruktor des Threads aufgerufen wird, packst Du ihn am besten in eine Klasse oder Struct.

Also ich meine jetzt eigentlich, dass der Thread in einem anderen Gültigkeitsbereich erstellt wird, als in dem er gebraucht wird. Soll heißen, wenn ich den Thread in der blaexe() Funktion erstelle, wird er ja durch den Dekonstruktor automatisch zerstört und ich kann ihn dann z.B. nicht mehr in der Main benutzen. Er soll dann aber noch weiter laufen. Und wenn ich aus blaexe eine Struktur mache, löst das ja mein Problem noch nicht. Ich könnte die thread Klasse static machen, aber ich glaube das ist nicht die Ideallösung. Kann ich einen Thread wirklich nur über den Konstraktor erstellen? Anscheinend ja, weil wofür der Konstruktor ohne Parameter ist, hab ich jetzt verstanden.

Wie lässt sich das Problem lösen?

mfg.

boost::thread* foo() {
  return new boost::thread(xyz);
}

Dann gibts da ja noch die Möglichkeit die Threads in einem Vector zu sammeln und den Vector rumzuschleppen.

thread_vec.push_back(new boost::thread(xyz));

Du siehst, Thread-Objekte mußt du wie alle anderen Objekte behandeln.

Insofern ist hier keine Patentlösung präsentierbar. Kannste nämlich auch in einer Factory erzeugen, deine Threads. Mußt du selber entscheiden.

mfg.

auto_ptrZeiger = new boost::thread(boost::bind(par1, par2, par3, &par4));

Allerdings erwartet der operator= ein weiteres auto_ptr Objekt und ein cast bringt hier nichts. Außerdem habe ich wieso gehört, dass sich der operator= von auto_ptr anders als gewöhnlich verhält.
Hat jemand ne Referenz zu auto_ptr? Ich habe auf cppreference.com und bei google schon gesucht, aber da war nur die Grundfunktion über den Konstruktor

mfg.

auto_ptrZeiger = new boost::thread(boost::bind(par1, par2, par3, &par4));

Allerdings erwartet der operator= ein weiteres auto_ptr Objekt und ein cast bringt hier nichts.

Es würde schon so gehen:

p = auto_ptr<boost::thread>(new boost::thread(boost::bind(par1, par2, par3, &par4)));

aber besser ist die reset-Methode:

p.reset(new boost::thread(boost::bind(par1, par2, par3, &par4)));

mfg.