C++ How to Reference Templated Functions using std::bind / std::function

Question

If you have a templated class or a templated function, (or combination of the two), how do you bind that function, (preserving the template type parameter)?

I was gi

Answer 1

The template argument for std::function should be the signature of the function after template type substitution has been done. In your case, neither TemplateType nor FunctionTemplateType have an effect on the signature of the member function MyFunction - it will always return a std::string and take a single std::string argument. Therefore, the std::function you're going to store in your std::vector should be:

static std::vector<std::function<std::string(std::string)>> Functions;

Recall that a member function has an implicit first argument this. You need to bind the first argument of MyClass<...>::MyFunc<...> to the object you want it to be called on. Presumably, since you're binding the function in MyClass's constructor, you want the object to be that MyClass instance. That means your push_back should look like this:

Storage::Functions.push_back(
  std::bind(&MyClass<TemplateType>::MyFunction<int>, this,
    std::placeholders::_1)
);

Now the function that is pushed into Functions is bound to your MyClass object and takes a single argument of type std::string. You can call one of these functions like so:

Storage::Functions[0]("something");

Answer 2

If I understood you right... :)

What you want to do is not possible because for template<class T> void foo(T) functions foo<int>() and foo<double> are of different types and you can not create vector holding pointers to both that functions directly because vector is homogeneous container.

To overcome that we can use boost::variant<> to either store pointers to different types of functions or to store arguments of functions.

template<class T> void foo(T);
typedef boost::variant<void (*)(int), void (*)(double)> func_ptr_variant;
std::vector<func_ptr_variant> v;
v.push_back(foo<int>);
v.push_back(foo<double>);

typedef boost::variant<int, double> argument;
std::vector<void (*)(argument)) v;
v.push_back(foo);
v.push_back(bar);
// foo and bar are defined as void foo(argument a) and void bar(argument a)

Unfortunately, in any case you will need to instantiate function templates before inserting them to container because C++ can not do code generation on the fly. I think that it is possible that you know all possible types of arguments that the function may be used with so that may be not a problem.

Answer 3

MyClass's c-tor doesn't know anything about FunctionTemplateType that's why it can push_back only explicit specialized (sorry, it's term of mine... I don't know the right term) like this

#include <functional>
#include <vector>
#include <string>

struct Storage
{
  // Have no idea what this signature should really be:
  static std::vector<std::function<void ()>> Functions;

};
std::vector<std::function<void ()>> Storage::Functions;

template <typename TemplateType>
class MyClass
{
   template <typename FunctionTemplateType>
   std::string MyFunction(std::string myParameter)
   {
     return "Hellö: " + myParameter;

   }
public:
   MyClass()
   {
      Storage::Functions.push_back(
          std::bind( & MyClass<TemplateType>::MyFunction<std::string>, this, "borisbn" )
//                                                       ^^^^^^^^^^^
      );
   }
};

int main() {
    MyClass<int> obj;
}

liveworkspace link

Answer 4

The key issues is that in C++11 you cannot do something like:

// Doesn't compile
template <typename TemplateType>
static std::function<void(std::shared_ptr<TemplateType>)> Function;

Classes and Functions can be templated, but not member properties.

The "Magic" is:

/*******************************************************************/
// Define a Function Pointer in a Container
class Storage
{
   template <typename TemplateType>
   struct FunctionContainer {
       static std::function<void(std::shared_ptr<TemplateType>)> Function;
   };
};
/*******************************************************************/
// Initialize FunctionContainer's Static Function Pointer if using static pointer.
template <typename TemplateType>
std::function<void(std::shared_ptr<TemplateType>)> Storage
    ::FunctionContainer<TemplateType>::Function;

You can then Bind a templated function to this function like:

// Bind Function Pointer in Container to a Local Function
class MyClass
{
   template <typename TemplateType>
   void MyFunction(std::shared_ptr<TemplateType> parameter)
   {
     // Do something.
     // You can make this templated or non-templated.
   }
   MyClass()
   {
     // If you really want, you can templatize std::string in the following:
     Storage::FunctionContainer<std::string>::Function 
       = std::bind(&MyFunction<std::string>, this, std::placeholders::_1);
   }
}

And you can invoke all of this and provide a templated type parameter like so:

//Invocation
std::shared_ptr<std::string> parameter;
parameter->get() = "Hello World".
Storage::FunctionContainer<std::string>::Function(parameter);