std::thread overload not resolved (with right arguments)

Question

#include <thread>
#include <iostream>
using namespace std;

class A
{
    public:
    A(){}
    void m(std::string* s)
    {
     cout<<*s;
    }
    void m(std::string s)
   {
     cout<<s;
   }
};    

int main()
{
 A a;
 string str="hi!\n";
 std::thread(&A::m,a,&str);

}

this doesn't compile; it gives:

error: no matching function for call to ‘std::thread::thread(<unresolved overloaded function type>, A&, std::string*)’

if I remove the second member it compiles! why? I can't use overloaded methods in std::thread?

Wintermute · Accepted Answer · 2014-12-09 22:32:04Z

6

You can, but you have to pick the desired overload manually:

std::thread th(static_cast<void (A::*)(std::string*)>(&A::m),a,&str);

Or you could use a lambda:

std::thread th([&] { a.m(&str); });

Addendum: The reason this can't be deduced automatically is, in short, that the compiler looks only skin-deep when searching for the right constructor. Finding (making!) the right constructor from the relevant constructor template of the std::thread class involves template argument deduction, and template argument deduction looks, as a rule, only at the signatures and not the internals of a function template (in this case a constructor template, which is for our purposes the same). The relevant constructor template is

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

...which does not in itself say anything about the interplay of f and args in the depths of the implementation. There is not enough information in it to decide that only one overrload of A::m can work, so the ambiguity cannot be resolved, and you have to do it manually.

Whether it is actually possible and/or practical to make the compiler look deeper to resolve such ambiguities is an interesting question. I imagine it would be quite a challenge. Either way, it has not yet been done.

edited Dec 9, 2014 at 22:32

answered Dec 9, 2014 at 22:02

Wintermute

44.3k5 gold badges85 silver badges85 bronze badges

Sign up to request clarification or add additional context in comments.

6 Comments

David G Over a year ago

@volperossa The error has nothing to do with std::thread. &A::m itself is ambiguous because the compiler doesn't know which m you're referring to.

Wintermute Over a year ago

I extended the answer a bit to address that. Superficially, because explaining template argument deduction in detail is tedious; the rules are fairly complex. There's a link, if you're interested.

Lightness Races in Orbit Over a year ago

@volperossa: If std::thread's constructor were a part of the core language then, yes. But it's not. It's just a function from a library (albeit the standard library). It has to conform to the rules of the language and without any special treatment &A::m is ambiguous here. The language doesn't know that it could theoretically figure out which overload to use from the other arguments, because it has no idea what those arguments mean.

Jonathan Wakely Over a year ago

What the constructor does is roughly equivalent to: auto f = &A::m; auto obj = a; auto arg = &str; (obj.*f)(arg); and it can't determine the type of f in the first statement. The function call that happens later is too late to influence the type deduction that is needed for auto f = &A::m;

volperossa Over a year ago

thanks! just a thing: std::thread th(static_cast<void (A::*)(std::string*)>(&A::m),a,&str); the second parameter would be a pointer to the object owner of the method...so..it wouldn't be &a?

|

Collectives™ on Stack Overflow

std::thread overload not resolved (with right arguments)

1 Answer 1

6 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

6 Comments

Your Answer

Sign up or log in

Post as a guest

Related