Unklare Compiler Fehlermeldung

Ich habe boost mit threads installiert. Ich muss Multithreading unter C++ lernen. Dazu habe ich folgendes Programm geschrieben:

#ifndef TESTMULTITHREADING_H
#define TESTMULTITHREADING_H

#include <boost/thread.hpp>

class TestMultiThreading {

	public:
	TestMultiThreading();
	void writeSomething( int num );

};

#endif

und

#include "TestMultiThreading.h"

#include <stdio.h>

TestMultiThreading::TestMultiThreading() {
	for( int i = 1; i <= 3; ++i )
		boost::thread myThread( writeSomething, i );
}

void TestMultiThreading::writeSomething( int num ) {
	for( int i = 0; i < 10; ++i )
		printf("Ich bin Thread %d\n", num);
}

int main( int argc, const char* argv[] ) {
	printf( "MultiThreading?\n" );
	TestMultiThreading mt;
}

Nun erhalte ich beim Kompilieren folgenden Fehler:

[anthovak@findthee test]$ make
g++ -m64 -g -Wall -Werror -Wcomment -I./boost_1_43_0/include -o TestMultiThreading.o -c TestMultiThreading.cpp
TestMultiThreading.cpp: In constructor ‘TestMultiThreading::TestMultiThreading()’:
TestMultiThreading.cpp:7: error: no matching function for call to ‘boost::thread::thread(<unresolved overloaded function type>, int&)’
./boost_1_43_0/include/boost/thread/detail/thread.hpp:248: note: candidates are: boost::thread::thread(F, A1) [with F = void (TestMultiThreading::*)(int), A1 = int]
./boost_1_43_0/include/boost/thread/detail/thread.hpp:214: note:                 boost::thread::thread(boost::detail::thread_move_t<boost::thread>)
./boost_1_43_0/include/boost/thread/detail/thread.hpp:200: note:                 boost::thread::thread(F, typename boost::disable_if<boost::is_convertible<T&, boost::detail::thread_move_t<T> >, boost::thread::dummy*>::type) [with F = void (TestMultiThreading::*)(int)]
./boost_1_43_0/include/boost/thread/detail/thread.hpp:153: note:                 boost::thread::thread()
./boost_1_43_0/include/boost/thread/detail/thread.hpp:121: note:                 boost::thread::thread(boost::detail::thread_data_ptr)
./boost_1_43_0/include/boost/thread/detail/thread.hpp:111: note:                 boost::thread::thread(boost::thread&)
make: *** [TestMultiThreading.o] Error 1

Nun verstehe ich die Fehlermeldung so, dass "boost::thread::thread(<unresolved overloaded function type>, int&)" nicht mit zB "boost::thread::thread(F, A1) [with F = void (TestMultiThreading::*)(int), A1 = int]" übereinstimmt.

Wie sage ich denn boost::thread, dass das erste Argument eine Methode vom Typ "void (TestMultiThreading::*)(int)" ist und "A1 = int" ?

TyRoXx

boost.bind dürfte bei der Methode helfen.

for( int i = 1; i <= 3; ++i )
        boost::thread myThread( writeSomething, i );

Das ist wahrscheinlich so nicht möglich, weil die thread -Objekte zerstört werden, bevor der Thread jeweils zuende ist.
Mach das ungefähr so:

boost::array<std::auto_ptr<boost::thread>, 3> threads;
for (size_t i = 0; i < threads.size(); ++i)
{
	threads[i].reset(new boost::thread(boost::bind(&TestMultiThreading::writeSomething, this, i)));
}
for (size_t i = 0; i < threads.size(); ++i)
{
	threads[i]->join();
}

Okay, danke für die Antwort.

Gibt es eigentlich ein gute Dokumentation zu boost. Die offizielle Doku auf deren Homepage ist vollkommen miserabel. Ich versteh da jedenfalls garnix.

Ich habe jetzt schon wieder ein Problem, das ich mir nicht mit Hilfe der boost Doku erklären oder lösen kann. Nun habe ich folgendes, wie ich denke sehr einfaches Problem, das ich nicht gelöst bekomme.

TestMultiThreading::TestMultiThreading() {

	boost::thread thread1( boost::bind( &TestMultiThreading::provide_data, this ) );
	boost::thread thread2( boost::bind( &TestMultiThreading::process_data, this ) );

	thread1.join();
	thread2.join();
}

void TestMultiThreading::provide_data( boost::thread thread ) {
	for( int i = 0; i < 10; ++i ) {
		boost::mutex::scoped_lock lock(mtx);
		var = i; 
		boost::thread::sleep(1); <-- Zeile 38
	}
}

void TestMultiThreading::process_data() {
	int local_var = 0;
	while( local_var != 9 ) {
		boost::mutex::scoped_lock lock(mtx);
		local_var = var;
		cout << local_var << endl;
	}
}

Compiler meckert und will nicht.

[anthovak@findthee test]$ make
g++ -m64 -g -Wall -Werror -Wcomment -I./boost_1_43_0/include -o TestMultiThreading.o -c TestMultiThreading.cpp
TestMultiThreading.cpp: In member function ‘void TestMultiThreading::provide_data()’:
TestMultiThreading.cpp:38: error: invalid conversion from ‘int’ to ‘boost::date_time::special_values’
TestMultiThreading.cpp:38: error: initializing argument 1 of ‘boost::posix_time::ptime::ptime(boost::date_time::special_values)’
make: *** [TestMultiThreading.o] Error 1

Wie kann ich denn dem Programm sagen, dass der Thread der aktuell die Mehtode provide_data ausführt, mal ne Sekunde warten soll bis er weitermacht?

Okay, ich habs dann sogar doch noch hinbekommen. Hier ist der Code. Thread1 "erzeugt" Zahlen, die dann von Thread2 ausgegeben werden sollen und zwar so, dass bei der Variablenübergabe nur exklusiv gelesen/geschrieben werden darf.

#ifndef TESTMULTITHREADING_H
#define TESTMULTITHREADING_H

#include <boost/thread.hpp>
#include <boost/thread/mutex.hpp>

class TestMultiThreading {

	public:
	boost::mutex mtx;
	int var;
	TestMultiThreading();
	void provide_data();
	void process_data();

};

#endif

#include "TestMultiThreading.h"

#include <stdio.h>
#include <iostream>
#include <boost/array.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>

using std::cout;
using std::endl;

TestMultiThreading::TestMultiThreading() {

	boost::thread thread1( boost::bind( &TestMultiThreading::provide_data, this ) );
	boost::thread thread2( boost::bind( &TestMultiThreading::process_data, this ) );

	thread1.join();
	thread2.join();
}

void TestMultiThreading::provide_data() {
	for( int i = 0; i < 10; ++i ) {
		boost::posix_time::time_duration td(0,0,2,0);
		boost::this_thread::sleep(td);

		mtx.lock();
		cout << "Thread 1 lock" << endl;
		var = i;
		cout << "Thread 1 unlock" << endl;
		mtx.unlock();

	}
}

void TestMultiThreading::process_data() {
	int local_var = -1;
	while( local_var != 9 ) {
		boost::posix_time::time_duration td(0,0,1,0);
		boost::this_thread::sleep(td);

		mtx.lock();
		cout << "Thread 2 lock" << endl;
		local_var = var;
		cout << "Thread 2 unlock" << endl;
		mtx.unlock();

		cout << local_var << endl;
	}
}

int main( int argc, const char* argv[] ) {
	printf( "MultiThreading?\n" );
	TestMultiThreading mt;
}