CODEWITHSUNDEEP
c++multithreadingc++11
liangbright
liangbright

Reputation: 152

std thread call template member function of template class: compiler error

Here is the code. It does not compile in vs2013, but does compile in gcc4.8

error C2665: 'std::thread::thread' : none of the 4 overloads could convert all the argument types

Since I am using vs2013, can anyone provide workaround? 

#include <iostream>
#include <thread>

template<typename T> 
class TestClass
{
public:
    TestClass(){};
    ~TestClass(){};

    T  t;

    template<typename U>
    void fun(U u)
    {
        std::cout << "fun: " << u << '\n';
    }
};

int main()
{
    TestClass<double>  A;

    auto aaa = std::thread(&TestClass<double>::fun<int>, &A, 1);
}

Upvotes: 4

Views: 3484

Answers (2)

Buddhika Chaturanga
Buddhika Chaturanga

Reputation: 993

There is another way you can achieve above problem,If you would mind ! First just look explicit constructor of thread object:

template< class Function, class... Args > 
explicit thread( Function&& f, Args&&... args );

f - Universal reference for function object.

args - variadic arguments for function(functor) f.

(I am not going to explain deeper and deeper about variadic calling used here). So now we know we can deal with functors therefore, Define a functor(function object) like below :

template<typename T>
class TestClass
{
public:
    TestClass(){};
    ~TestClass(){};

    T  t;

    template<typename U>
    void operator()(U u1,U u2){
        std::cout << "fun: " << u1*u2 << '\n';
    }

};
int main()
{
    TestClass<double>  A;
    auto aaa = std::thread(A,1,100);// calling functor A(1,100)
    aaa.join()
    //or if you can move object from main thread to manually created thread aaa ,it's more elegant.
    auto aa = std::thread(std::move(A),1,100);
    aa.join();
    A(1, 99);
    system("Pause");
    return 0;
}

//Please notice here I've not used any locker guard system. If you use static function you don't have to bind respective instance each time this may change your expected run-time behavior therefore you have to managed,

 template<typename U>
    static void fun(U u)
    {
        std::cout << "fun: " << u << '\n';
    }
then invoke the function,
int main()
{
    TestClass<double>  A;
    auto aaa = std::thread(&TestClass<double>::fun<int>, 1);
    system("Pause");
    return 0;
}

Upvotes: 1

Adam H. Peterson
Adam H. Peterson

Reputation: 4591

You could simply use a lambda rather than monkeying with member function pointers:

auto aaa = thread( [&]{ A.fun(1); } );
aaa.join();

Upvotes: 13

Related Questions