C++ 11 cmake O3 Option <kein passender Konstruktor für die Initialisierung von 'std :: thread'>

Question

Ich benutze C++ mit CMake Makefile mit -std=c++11.

Mein Programm verwenden mehrere Thread-Methode. Ich kann mein Programm ohne Probleme erstellen und ausführen.

Aber wenn ich -03 Optimierung Flagge auf CMake Option hinzufügen, ich habe diese Fehlermeldung:

"Keinen passenden Konstruktor zur Initialisierung von 'std :: thread'"

Erste I d 'ont verstehen, warum nur in -O3 Option erscheint.

Second Ich mag würde in -O3 kompilieren, sehe ich andere Q & A, die über mythread = std::thread(&X::run<A, B>, this, a, b); sprechen, aber es funktioniert nicht in meinem Programm und ich verstehe nicht, wie zu bedienen.

Hier ist meine Funktion möchte ich in Thread nehmen:

static void getPoints(Mat *in, vector<Point> *posPoint, float *h,int rad, int dex,int decy, Mat *debug = NULL); 

Heute habe ich sehr einfach anrufen mit: std::thread t1(get4points,&myImage, ...

Bei std::thread(&X::run<A, B>, this, a, b); Ich verstehe nicht, was genau &X::run<A, B> ist, bei Ich rufe eine Funktion einer Klasse in einer Funktion derselben Klasse auf. Pseudo-Code

Beispiel:

class myclass 
{ 
    template<int A, int B> void run(int a, int b) 
    { 
     // ... 
    } 

    void myMainfunction(int a, int b) 
    { 
     ?????? -> std::thread(&this::run<int, int>, this, 1, 1); 
    } 
}; 

Answer 1

Von Ihrem Codebeispiel müssen Sie alle Ihre Template-Parameter definieren die konkrete Funktion angeben, in dem Thread-Konstruktor übergeben.

Also, wenn Sie haben:

class myclass 
{ 
    template<int A, int B> void run(int a, int b) 
    { 
    } 
}; 

Sie haben für A die Parameter angeben & B wie:

auto x = std::thread(&myclass::run<55, 66>, this, 1, 1); 

Wenn Ihre Methode static ist, gibt es kein ähnliches Objekt überhaupt, so dass es Es macht keinen Sinn, den Objektzeiger an den Thread-Konstruktor zu übergeben. Sie einfach zu schreiben haben:

class myclass 
{ 
    template<int A, int B> static void run(int a, int b) 
    { 
    } 
}; 


auto x = std::thread(&myclass::run<77, 88>, 1, 1); 

Sie fragen:

Bei std :: Gewinde (& X :: run, this, a, b); Ich verstehe nicht, was genau ist & X :: run, im Falle von ich eine Funktion einer Klasse in einer Funktion der gleichen Klasse aufrufen.

Sie verstehen den Unterschied zwischen Klasse und Objekt nicht! this verweist auf ein Objekt Ihrer Klasse und nicht auf eine Klasse selbst. Fangen Sie an, über die Grundlagen von C++ zu lesen, bevor Sie mit Vorlagenmaterial herumspielen. Im Falle einer static Funktion gibt es kein Objekt wie bereits erwähnt.

eine Vorstellung zu bekommen, wenn die this Zeiger, das Objekt und den Anruf auf nicht statische Funktionen zu sehen, in diesem Beispiel mit:

class myclass 
{ 
    private: 
     int ia; 

    public: 
     myclass(int _ia): ia{_ia}{} 

     template<int A, int B> static void staticFun(int a, int b) 
     { 
      std::cout << "Val of A: " << A << " Val of B: " << B << " a: " << a << " b: " << b << std::endl; 
     } 

     template<int A, int B> void Fun(int a, int b) 
     { 
      std::cout << "Val of A: " << A << " Val of B: " << B << " a: " << a << " b: " << b << " ia of instance: " << ia << std::endl; 
     } 
}; 

int main() 
{ 
    myclass mc1(1); 
    myclass mc2(2); 

    auto x = std::thread(&myclass::staticFun<55, 66>, 1, 2); 
    auto y = std::thread(&myclass::Fun<77,88>, &mc1, 3, 4); 
    auto z = std::thread(&myclass::Fun<78,89>, &mc2, 5, 6); 


    x.join(); 
    y.join(); 
    z.join(); 
} 

Ausgang so etwas wird:

Val von A: B 55 Val von: 66 a: 1 b: 2

Val von A: B 77 Val von: 88 A: B 3: 4 von Beispiel IA: 1

Val von A: 78 Val von B: 89 a: 5 b: 6 ia der Instanz: 2

Aber denken Sie daran, dass der Betreiber << von std :: cout Aufruf wird nicht überhaupt synchronisiert werden. So kann jeder Thread jederzeit in den Stream schreiben und das Ergebnis wird beschädigt oder in beliebiger Reihenfolge.