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

Ответ 1

Ключевыми проблемами являются то, что в С++ 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 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);

Ответ 2

Аргумент шаблона для 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");

Ответ 3

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

То, что вы хотите сделать, невозможно, потому что для шаблона < 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)

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

Ответ 4

MyClass c-tor ничего не знает о 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;
}

ссылка liveworkspace