błąd C2661programowanie wielowatkowe

Question

następujący kod powoduje błąd:
Błąd    C2661    "std::tuple<std::packaged_task<mala_macierz (long **,long **,long,long,long)>,long **,long **,long,unsigned long,unsigned long>::tuple": brak przeciążonej funkcji przyjmującej 6 argumenty    macierze   

linia3437 memory -wadliwy kod oznaczyłem znakami komentarz

#include "mnożenie.h"
#include "generator.h"
#include <thread>
#include <vector>
#include <future>
using namespace std;

class join_thread {
	vector<thread> temp;
public:
	join_thread(vector<thread>& temp_) :temp(temp_) {
	}

	~join_thread() {
		for (auto& i : temp)
			if (i.joinable())
				i.join();
	}
};

mnozenie::mnozenie(long** tab1_, long** tab2_, long rozmiar_):
tab1(tab1_),tab2(tab2_),rozmiar(rozmiar_) {
}

long** mnozenie::mnozenie_wierszami(){
	long** tablica= generator(rozmiar, rozmiar, true).tab;
	class glowna {
	public:
		mala_macierz operator()(long** tab1, long** tab2, long rozmiar, long od_, long do_) {
			mala_macierz temp = generator(do_ - od_, rozmiar, true);
			for (long i = od_; i < do_; i++)
				for (long j = 0; j < rozmiar; j++)
					for (long k = 0; k < rozmiar; k++)
						temp.tab[i][j] = tab1[i][k] * tab2[k][j];
			temp.do_ = od_;
			temp.do_ = do_;
			return temp;
		}
	};
	const unsigned long max_per_thread = 25;
	const unsigned long max_thread = ((rozmiar * rozmiar) + max_per_thread - 1) / max_per_thread;
	const unsigned long hardware_threads = thread::hardware_concurrency();
	const unsigned long num_threads = min(max_thread, (hardware_threads > 0 ? hardware_threads : 0));
	const unsigned long block_size = rozmiar / num_threads;
	vector<future<mala_macierz>> vec1(num_threads-1);
	vector<thread> vec2(num_threads-1);
////////////////////////////////////////////////////////////////////////	
	join_thread joiner(vec2);
	long t;
	for (t = 0; t < num_threads-1; t++) {
		packaged_task<mala_macierz(long**, long**, long, long, long)> temp{ glowna() };
		vec1[t] = temp.get_future();
		vec2[t] = thread(temp, tab1, tab2, rozmiar, t * block_size, t * block_size + block_size);
	}
////////////////////////////////////////////////////////////////////////////////
	mala_macierz ostatnia = glowna()(tab1, tab2, rozmiar, t * block_size, rozmiar);
	for (long i = 0; i < num_threads; i++) {
		mala_macierz  czesc = ((num_threads - 1 == i)?ostatnia:vec1[i].get());
		for (long j = czesc.od_,l=0; j < czesc.do_; j++,l++) {
			for (long k = 0; k < rozmiar; k++) {
				tablica[j][k] = czesc.tab[l][k];
			}
		}
	}
	return tablica;
}

long** mnozenie::mnozenie_kolumanami(){
	return nullptr;
}

long** mnozenie::mnozenie_kwadratami(){
	return nullptr;
}

long** mnozenie::zwykle_mnozenie(){
	mala_macierz tab = generator(rozmiar,rozmiar, true);
	for (long i = 0; i < rozmiar; i++)
		for (long j = 0; j < rozmiar; j++)
			for (long k = 0; k < rozmiar; k++)
				tab.tab[i][j]+= tab1[i][k] * tab2[k][j];
	return tab.tab;
}

long** mnozenie::daj_macierz1(){
	return tab1;
}

long** mnozenie::daj_macierz2(){
	return tab2;
}

void mnozenie::zmien_macierz1(long** tab1_){
	tab1 = tab1_;
}

void mnozenie::zmien_macierz2(long** tab2_){
	tab2 = tab2_;
}

long mnozenie::daj_rozmiar(){
	return rozmiar;
}

void mnozenie::zmien_rozmiar(long rozmiar_){
	rozmiar = rozmiar_;
}

 

Comments

thread się nie znam, ale na mój gust, kompilator pisze, że nie ma takiego  konstruktora.

thread(class obj, ...arg), sprawdzałem tu

Answer 1

Spróbuj:

vec2[t] = thread(std::move(temp), ...);

 

Comments

Działa ale teraz wyskakuje błąd Ważność   
Błąd    C2280    „std::thread::thread(const std::thread &)”: próba odwania do usuniętej funkcji    macierze

---

To jest kompletna treść błędu i w tej linii, którą podałem?

PS. skoro nie używasz std::future do synchronizacji, bo czekasz aż wątek skończy robotę, to nie lepiej użyć std::bind zamiast bawić się z std::packaged_task?

---

Tu jest chyba błąd:

class join_thread {
    vector<thread> temp; // <--- !!!
public:
    join_thread(vector<thread>& temp_) 
        :temp(temp_)  // <--- tworzysz kopie wątków, a tego nie możesz robić