use of std::bind and std::function

Question

EDIT3: If I delete the second createTriangle function, it works. So how can I bind overloaded functions?

I have a function which takes a function object with one parameter, like this:

int createObject(std::function<void(int)>);

How can I call this function with std::bind? I tried it like this:

createObject(std::bind(&ClassA::createTriangle, std::placeholders::_1, a, b, c, color));

But this gives me an error:

candidate template ignored: couldn't infer template argument

ClassA::createTriangle is a static function.

Additional info:

void ClassA::createTriangle(int id, const glm::vec3 & a, const glm::vec3 & b, const glm::vec3 & c, const glm::vec3 & col) {
    /* ... */
}

int ClassB::createTriangle(const glm::vec3 & a, const glm::vec3 & b, const glm::vec3 & c, const glm::vec3 & color) {
    return classCInstance.createObject(std::bind(&classA::createTriangle, std::placeholders::_1, a, b, c, color));
}

int ClassC::createObject(std::function<void(int)> f) {
    f(++id);
    return id;
}

There is another static createTriangle function in ClassA, with a different last parameter. Is that maybe a problem? Does bind not know which createTriangle to choose? It looks like this:

void ClassA::createTriangle(int id, const glm::vec3 & a, const glm::vec3 & b, const glm::vec3 & c, const std::initializer_list<glm::vec3> & colors) {
    /* ... */
}

Why aren't we allowed to see the declaration of `ObjectInterface::createTriangle`? — Kerrek SB, Mar 09 '14 at 15:32
Too unanswerable without the important information! Reverted... — Kerrek SB, Mar 09 '14 at 15:41
Ok, sorry. And thanks for reverting. Is this enough info or do I need to post more? — gartenriese, Mar 09 '14 at 15:44
No - what are `a`, `b` etc? And does `createTriangle` only have that one overload? — Kerrek SB, Mar 09 '14 at 15:46
You can see what a and b is in the parameter list of the functions. They are const glm::vec3 &. — gartenriese, Mar 09 '14 at 15:47
But I can't see what the arguments of the `bind` call are, and if they match, etc. — Kerrek SB, Mar 09 '14 at 15:47
I edited my question. Also, you can see what arguments the bind call uses in Engine::createTriangle which I posted earlier. Or do you mean something else? — gartenriese, Mar 09 '14 at 15:50
@OMGtechy: That's just a typedef for an unsigned int. I will try to generalize my question. — gartenriese, Mar 09 '14 at 16:28
Yes this is because of the overloaded createTriangle. Just use lambda, it's as easy as it gets. — n. m. could be an AI, Mar 09 '14 at 16:53
@n.m.: Yes, lambdas seem to work. Why does std::bind not work? — gartenriese, Mar 09 '14 at 16:58
You generally cannot bind an overloaded function, it's just a limitation of bind. You can disambiguate with various methods, but it's not worth it, lambdas are just easier. — n. m. could be an AI, Mar 09 '14 at 17:00

score 7 · Accepted Answer · answered Mar 09 '14 at 17:02

7

ClassA::createTriangle is an overloaded function, you cannot use it without specifying which overload you intend to use. std::bind has to return a generic wrapper, it cannot figure it by itself, you have to specify.

This should work:

void (*mySpecificCreateTriangle)(int, const const glm::vec3 &, const const glm::vec3 &, const const glm::vec3 &, const const glm::vec3 &) = &createTriangle;
createObject(std::bind(mySpecificCreateTriangle, std::placeholders::_1, a, b, c, color));

Since you are using C++11, you will be happier with a lambda:

createObject([=](int id){ return createTriangle(id, a, b, c, color); });

answered Mar 09 '14 at 17:02

Juliano

39,173
13
67
73

Are you sure std::function will take a lambda? – thor Mar 09 '14 at 17:08
@TingL: Yes, the whole purpose of std::function is to wrap any callable object, including a lambda. – Juliano Mar 09 '14 at 17:10
@gartenriese Last time I checked, if you have `int createObject(std::function); ` and call it with a lambda `createObject([=](int id){ return createTriangle(id, a, b, c, color); });`, there will be compile error in gcc. – thor Mar 09 '14 at 17:11
@Ting L: I use clang, so maybe you're right about gcc. – gartenriese Mar 09 '14 at 17:12
Oh, do you mean because of the return? I don't use a return, Juliano must have added it by accident. – gartenriese Mar 09 '14 at 17:13
@TingL: It is probably a bug in you version of GCC. It works for me in both GCC and CLANG, and on ideone too: https://ideone.com/80ySfX – Juliano Mar 09 '14 at 17:15
@gartenriese No, it's not about the return. I think a lambda is not considered a `std::function` object, and at least gcc does not take care of the implicit conversion from lambda to the corresponding `std::function` object. – thor Mar 09 '14 at 17:16
It is okay to return the result of a void function, the return type of the lambda will also be void. – Juliano Mar 09 '14 at 17:16
@Juliano Your code works for my version of gcc as well. Maybe it will not work when the function is a template. For example, https://ideone.com/IBUCyX – thor Mar 09 '14 at 17:24
@TingL: The problem is that you are trying to infer the arguments of two nested templates at the same time (the std::function<> constructor and the map<> function), and C++ doesn't know how to do that. This is the fixed version of your example: https://ideone.com/vlqeL0 – Juliano Mar 09 '14 at 17:33
@Juliano Yes. That is what I was referring to. Have to assign to a `std::function` object first, and cannot directly use it when templates are involved. – thor Mar 09 '14 at 18:33
If the `createObject` function here were templated, then a lambda has to be assigned to a std::function first before it can be used. – thor Mar 09 '14 at 18:39

use of std::bind and std::function

1 Answers1