C++ Как ссылаться на шаблонные функции с помощью std::bind/std::function

Ключевая проблема заключается в том, что в С++ 11 вы не можете сделать что-то вроде:

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

Классы и функции могут быть шаблонными, но не свойства членов.

"Магия" это:

/*******************************************************************/
// 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;

Затем вы можете привязать шаблонную функцию к этой функции, например:

// 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);
   }
}

И вы можете вызвать все это и предоставить параметр шаблонного типа следующим образом:

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

Аргумент шаблона для std::function должен быть сигнатурой функции после подстановки типа шаблона. В вашем случае ни TemplateType, ни FunctionTemplateType не влияют на подпись функции-члена MyFunction - она ​​всегда будет возвращать std::string и принимать один аргумент std::string. Следовательно, std::function, которое вы собираетесь хранить в std::vector, должно быть:

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

Напомним, что функция-член имеет неявный первый аргумент this. Вам нужно привязать первый аргумент MyClass<...>::MyFunc<...> к объекту, для которого вы хотите, чтобы он вызывался. Предположительно, поскольку вы привязываете функцию в конструкторе MyClass, вы хотите, чтобы объект был экземпляром MyClass. Это означает, что ваш push_back должен выглядеть так:

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

Теперь функция, помещенная в Functions, связана с вашим объектом MyClass и принимает один аргумент типа std::string. Вы можете вызвать одну из этих функций следующим образом:

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

Если я вас правильно понял... :)

То, что вы хотите сделать, невозможно, потому что для шаблона‹class T› void foo(T) функции foo‹int›() и foo‹double› имеют разные типы, и вы не можете создавать векторные указатели на обе эти функции напрямую, потому что вектор является однородным контейнером.

Чтобы преодолеть это, мы можем использовать boost::variant‹> либо для хранения указателей на различные типы функций, либо для хранения аргументов функций.

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)

К сожалению, в любом случае вам нужно будет создавать экземпляры шаблонов функций перед их вставкой в ​​контейнер, потому что C++ не может генерировать код на лету. Я думаю, что вполне возможно, что вы знаете все возможные типы аргументов, с которыми может использоваться функция, так что это может не быть проблемой.

c-tor MyClass ничего не знает о FunctionTemplateType, поэтому он может push_back только явно специализированный (извините, это мой термин... я не знаю правильный термин) вот так

#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;
}

ссылка на рабочее пространство