Вектор std::function с разными сигнатурами

Вы не сказали, что вы ожидаете сделать с func2 после помещения его в вектор с неправильным типом.

Вы можете легко использовать std::bind, чтобы поместить его в вектор, если заранее знаете аргументы:

const std::vector<std::function<void(std::string)>> functions
{
    func1,
    std::bind(func2, std::placeholders::_1, 5, 6)
};

Теперь functions[1]("foo") будет вызывать func2("foo", 5, 6) и каждый раз будет передавать 5 и 6 в func2.

Вот то же самое с использованием лямбда вместо std::bind

const std::vector<std::function<void(std::string)>> functions
{
    func1,
    [=](const std::string& s){ func2(s, func2_arg1, func2_arg2); }
};

Если вы еще не знаете аргументы, вы можете привязать ссылки к некоторым переменным:

int func2_arg1 = 5;
int func2_arg2 = 6;
const std::vector<std::function<void(std::string)>> functions
{
    func1,
    std::bind(func2, std::placeholders::_1, std::ref(func2_arg1), std::ref(func2_arg2))
};

Теперь functions[1]("foo") будет вызывать func2("foo", func2_arg1, func2_arg2), и вы можете присваивать новые значения целым числам, чтобы передавать различные аргументы в func2.

И используя лямбда-функцию вместо std::bind

const std::vector<std::function<void(std::string)>> functions
{
    func1,
    [&](const std::string& s){ func2(s, func2_arg1, func2_arg2); }
};

Однако это довольно уродливо, так как вам нужно сохранять переменные int до тех пор, пока существует вызываемый объект (замыкание или выражение привязки), ссылающийся на них.

То, что вы хотите, возможно через polymorphism. Идея состоит в том, чтобы создать класс с определенной сигнатурой, который во время выполнения будет вызывать разные методы. Например:

#include <iostream>
#include <functional>
#include <memory>
#include <vector>

void foo(int) {
    std::cout << "I'm foo!\n";
}

int bar(char, double) {
    std::cout << "I'm bar!\n";
}

class MyFunction {
    public:
        virtual ~MyFunction(){}

        virtual void operator()() = 0;
};

class MyFunctionA : public MyFunction {
    public:
        virtual void operator()() {
            foo(4);
        }
};

class MyFunctionB : public MyFunction {
    public:
        MyFunctionB(std::function<int(char,double)> f, char arg1, double arg2) : fun_(f), arg1_(arg1), arg2_(arg2) {} 

        virtual void operator()() {
            fun_(arg1_, arg2_);
        }
    private:
        std::function<int(char,double)> fun_;
        char arg1_;
        double arg2_;
};

int main() {
    using MyFunPtr = std::unique_ptr<MyFunction>;
    std::vector<MyFunPtr> v;

    v.emplace_back(new MyFunctionA());
    v.emplace_back(new MyFunctionB(bar, 'c', 3.4));

    for ( auto&& myfun : v ) {
        (*myfun)();
    }
    return 0;
}

Вы можете сделать производные классы настолько сложными, насколько вам нужно, но, поскольку в конце концов все они имеют один и тот же интерфейс, вы сможете вызывать их все.

Для C++ 17 std::variant можно использовать для хранения std::function с разными подписями. В этом случае функция std::holds_alternative позволяет различать между ними во время выполнения:

Образец:

#include <variant>
#include <iostream>
#include <functional>
#include <vector>


using FooInt = std::function<void(int)>;
using FooStr = std::function<void(std::string)>;

using FooVariant = std::variant<FooInt, FooStr>;

void foo(int a){
  std::cout << a << std::endl;
}

void bar(std::string a){
  std::cout << a << std::endl;
}

int main()
{
  std::vector<FooVariant> v;
  v.push_back(foo);
  v.push_back(bar);

  for(auto& f: v){
    if (std::holds_alternative<FooInt>(f))
      std::get<FooInt>(f)(1);
    else if (std::holds_alternative<FooStr>(f))
      std::get<FooStr>(f)("hello");
  }
}

Прямой ответ на ваш вопрос - "НЕТ". Любой контейнер среды выполнения позволит вам хранить объекты только одного типа, а экземпляры std::function‹> с разными сигнатурами будут разными типами данных.

Как правило, причина, по которой вы можете захотеть иметь «вектор функций с разными сигнатурами», заключается в том, что у вас есть что-то вроде приведенного ниже (трехэтапная обработка, где входной интерфейс унифицирован (buffer& buf и выходной интерфейс унифицирован on_event(Event evt)), но слой в середине неоднороден process_...(...)

receive_message(buffer& buf)
  switch(msg_type(buf))
    case A: 
    case B:
    ...

process_A(A& a, One x, Two y)
  ...
  dispatch(Event evt);
  ...

process_B(B& b, Three x);
  ...
  dispatch(Event evt);
  ...

В решении, не связанном с метапрограммированием, вы обычно предварительно готовите функтор, выполняющий сквозную операцию во время инициализации, и сохраняете его в векторе:

vector <std::function<void(buffer& buf)>> handlers;

Если у вас есть int и строка, вы не можете поместить их в один вектор, но вы можете поместить их в одну структуру или std::tuple<>. То же самое относится к двум типам функций.

std::function стирает точный тип объекта функции, но сохраняет сигнатуру вызова функции. Если вы не можете bind использовать дополнительные аргументы заранее, как рекомендует Джонатан Уэйкли, вы можете использовать boost::variant< std::function<...>, std::function<...> > в качестве члена вектора. Затем на месте вызова вы можете проверить, содержит ли вектор правильный тип функционального объекта, и вызвать его соответствующим образом.

Не уверен, насколько это будет полезно для вас, он основан на boost::any, избыточные параметры игнорируются. Вы можете добавить try...catch для boost::bad_any_cast, чтобы предотвратить сбой в случае несоответствия между типами аргументов и параметров. Хотя я думаю, что обычный std::bind - лучший выбор.

ДЕМО

#include <boost/any.hpp>
#include <functional>
#include <vector>
#include <cstddef>
#include <memory>
#include <tuple>
#include <utility>
#include <iostream>
#include <string>

struct IGenericFunction
{
    virtual ~IGenericFunction() = default;

    virtual void call(boost::any a1 = boost::any{}
                    , boost::any a2 = boost::any{}
                    , boost::any a3 = boost::any{}
                    , boost::any a4 = boost::any{}) = 0;
};

template <typename... Args>
class GenericFunction : public IGenericFunction
{
public:
    GenericFunction(std::function<void(Args...)> f) : _f{ f } {}

    virtual void call(boost::any a1 = boost::any{}
                    , boost::any a2 = boost::any{}
                    , boost::any a3 = boost::any{}
                    , boost::any a4 = boost::any{}) override
    {
        call_func(std::make_tuple(a1, a2, a3, a4)
                , std::make_index_sequence<sizeof...(Args)>{});
    }

private:            
    template <typename Tuple, std::size_t... Indices>
    void call_func(Tuple t, std::index_sequence<Indices...> s)
    {
        _f(boost::any_cast<
                typename std::tuple_element<Indices, Params>::type
           >(std::get<Indices>(t))...);
    }

    std::function<void(Args...)> _f;

    using Params = std::tuple<Args...>;
};

template <typename... Args>
std::shared_ptr<IGenericFunction> make_generic_function_ptr(void(*f)(Args...))
{
    return std::make_shared<GenericFunction<Args...>>(f);
}

void func1(const std::string& value)
{
    std::cout << "func1 " << value << std::endl;
}

void func2(const std::string& value, int min, int max)
{
    std::cout << "func2 " << value << " " << min << " " << max << std::endl;
}

int main()
{
    std::vector<std::shared_ptr<IGenericFunction>> functions;

    functions.push_back(make_generic_function_ptr(&func1));    
    functions.push_back(make_generic_function_ptr(&func2));

    for (auto f : functions)
    {
        f->call(std::string("abc"), 1, 2);
    }
}

Как упомянул JBL: как бы вы их назвали, если бы не знали их сигнатур?

Подумайте о том, чтобы превратить ваши min, max аргументы в тип параметра с некоторым базовым классом Parameter, сигнатура обратного вызова будет void(const std::string&, const Parameter&) или void(const std::string&, const Parameter*), если вы хотите, чтобы nullptr не указывало никаких дополнительных параметров. Теперь вашим обратным вызовам нужно будет проверить, были ли им заданы правильные параметры, если они есть. Это можно сделать с помощью посетителя, typeid или enum. Во всем этом есть плюсы и минусы.

Как вы будете решать, какой обратный вызов вызывать? Я думаю, вам следует превратить ваши обратные вызовы в стиле C в объекты-обработчики, они могут реализовать функцию bool canHandle(const Parameter&), чтобы проверить, применим ли обработчик к представленным параметрам.

Джонатан Уэйкли и Свалорзен представляют свой подход, в котором параметры и функция являются одним и тем же объектом (отношения 1-к-1). В этом примере они разделены (в случае, если у вас есть отношения «множество к нескольким»):

#include <cassert>
#include <string>
#include <typeinfo>
#include <vector>

class ParameterBase {
public:
    ParameterBase(const std::string& value) : m_value(value) { }
    virtual ~ParameterBase() { }
    const std::string& GetValue() const { return m_value; }
private:
    std::string m_value;
};

class HandlerBase {
public:
    virtual bool CanHandle(const ParameterBase& params) const = 0;
    virtual void Handle(const ParameterBase& params) = 0;
};

class Handler1 : public HandlerBase {
public:
     class Parameter : public ParameterBase {
     public:
          Parameter(const std::string& value) : ParameterBase(value) { }
          ~Parameter() { }
     };

     bool CanHandle(const ParameterBase& params) const { return typeid(Parameter) == typeid(params); }
     void Handle(const ParameterBase& params) {
          assert(CanHandle(params));
          const Parameter& p = static_cast<const Parameter&>(params);
          // implement callback1
     }
};

void foo(const std::vector<HandlerBase*>& handlers) {
     Handler1::Parameter params("value");
     for(auto handler : handlers)
         if(handler->CanHandle(params)) {
             handler->Handle(params);
             // no break: all handlers may handle params
             // with break: only first handler (if any) handles params
         }
}

Я попытался использовать указатель функции и преобразовал std::function‹int(int)›* в void*, он может быть успешно скомпилирован, но иногда это вызывает ошибку сегментации:

int Fun(int a)
{
    std::cout << a << std::endl;
    return ++(++a);
}

int main()
{
    std::function<int(int)> originPFun = Fun;
    void *ppFun;
    // ppFun = (void*)&Fun; // This way will cause segmentation fault
    ppFun = (void*)&originPFun; // This way can run seuccessful and get right result
    std::function<int(int)> *pFun = (std::function<int(int)>*)(ppFun);
    std::cout << (*pFun)(5) << std::endl;
    system("pause");
    return 0;
}