想象一下，我们有2个函数(void : ( void ) )和(std::string : (int, std::string))，我们还可以有10个函数。所有（或其中一些）采用不同的参数类型，并可以返回不同的类型。我们希望将它们存储在std::map中，因此我们得到这样的API：
//Having a functions like:
int hello_world(std::string name, const int & number )
{
name += "!";
std::cout << "Hello, " << name << std::endl;
return number;
}
//and
void i_do_shadowed_stuff()
{
return;
}
//We want to be capable to create a map (or some type with similar API) that would hold our functional objects. like so:
myMap.insert(std::pair<std::string, fun_object>("my_method_hello", hello_world) )
myMap.insert(std::pair<std::string, fun_object>("my_void_method", i_do_shadowed_stuff) )
//And we could call tham with params if needed:
int a = myMap["my_method_hello"]("Tim", 25);
myMap["my_void_method"];
我想知道如何将许多不同的功能放入同一个容器中。具体来说，如何使用Boost在C ++ 03中执行此操作。
API应独立于实际的功能类型（int a = myMap["my_method_hello"]("Tim", 25);而不是int a = myMap<int, (std::string, int)>["my_method_hello"]("Tim", 25);）。
答案 0 :(得分：7)
#include <functional>
#include <iostream>
#include <string>
#include <map>
class api {
// maps containing the different function pointers
typedef void(*voidfuncptr)();
typedef int(*stringcrintptr)(std::string, const int&);
std::map<std::string, voidfuncptr> voida;
std::map<std::string, stringcrintptr> stringcrint;
public:
// api temp class
// given an api and a name, it converts to a function pointer
// depending on parameters used
class apitemp {
const std::string n;
const api* p;
public:
apitemp(const std::string& name, const api* parent)
: n(name), p(parent) {}
operator voidfuncptr()
{ return p->voida.find(n)->second; }
operator stringcrintptr()
{ return p->stringcrint.find(n)->second; }
};
// insertion of new functions into appropriate maps
void insert(const std::string& name, voidfuncptr ptr)
{ voida[name]=ptr; }
void insert(const std::string& name, stringcrintptr ptr)
{ stringcrint[name]=ptr; }
// operator[] for the name gets halfway to the right function
apitemp operator[](std::string n) const
{ return apitemp(n, this); }
};
用法：
api myMap;
int hello_world(std::string name, const int & number )
{
name += "!";
std::cout << "Hello, " << name << std::endl;
return number;
}
int main()
{
myMap.insert("my_method_hello", &hello_world );
int a = myMap["my_method_hello"]("Tim", 25);
}
http://ideone.com/SXAPu不太漂亮。更好的建议就是不要做任何事情，就像你正在尝试做的那样。
请注意，这需要具有相同参数的所有函数返回相同的类型。
答案 1 :(得分：4)
你可以使用boost :: any ...
#include <boost/any.hpp>
#include <iostream>
#include <map>
#include <string>
void voidFunc()
{
std::cout << "void called" << std::endl;
}
void stringFunc(std::string str)
{
std::cout << str << std::endl;
}
int main()
{
std::map<std::string, boost::any> funcs;
funcs.insert(std::pair<std::string, boost::any>("voidFunc", &voidFunc));
funcs.insert(std::pair<std::string, boost::any>("stringFunc", &stringFunc));
boost::any_cast<void(*)(void)>(funcs["voidFunc"])();
boost::any_cast<void(*)(std::string)>(funcs["stringFunc"])("hello");
return 0;
}
请注意，如果未在any_cast中正确指定函数签名，则会收到运行时异常。
答案 2 :(得分：2)
事情是，不知何故，当你打电话给你的功能时，你已经知道它们将是什么类型。
如果我们做类似的事情
int x = map["key"](1, "2")
我们已经可以推断，“key”中存储的任何函数都是(int (*)(int, char*))类型，所以我们可能会做类似的事情
int x = map_of_int_and_string_to_int["key"](1, "2");
并避免将所有密钥合并在一起的麻烦...虽然C ++确实有一些超载功能正是这种东西，我真的不明白为什么你应该在这种特殊情况下烦恼。
最后，为什么要将所有这些功能放在同一个地图中？它们不共享任何类似的接口，因此您无法统一访问它们，您无法对它们进行迭代，也不能将它们不透明地传递给其他人。没有任何共同点，你无法安全地对这个假想图中的函数做任何事情。
答案 3 :(得分：0)
你可以通过将函数指针转换为void指针和返回来实现。您应该在运行期间知道签名，因此强制连接转换操作符不会成为问题。然而，这样做的逻辑逃脱了我。它完全没有意义，至少在C ++中是这样。使用模板类/函数或函数指针的结构更有意义。
例如，使用模板：
template <typename X> foo(X param1) { /* do something with param1*/};
template <typename X, typename Y> foo(X param1, Y param2)
{/* do something with 2 params*/};
template <int X> foo(X param1) { /* only one parameter, which is int */};
现在：
foo(5); // calls the third one
foo("5"); // calls the first one
foo("5", 5); // calls the second one.
谁需要地图？
答案 4 :(得分：0)
我们可以像boost :: any这样使用类型擦除。但是，由于我们只想保留功能，因此可以提出更方便的用法。
我们首先需要的是函数签名推导。参见here。
template <typename T>
struct function_traits : public function_traits<decltype(&T::operator())>
{};
template<typename R, typename ...Args>
struct function_traits<std::function<R(Args...)>>
{
typedef R result_type;
typedef typename std::function<R(Args...)> type;
typedef typename std::function<void(Args...)> typeNoRet;
};
template<typename R, typename ...Args>
struct function_traits<R(*)(Args...)>
{
typedef R result_type;
typedef typename std::function<R(Args...)> type;
typedef typename std::function<void(Args...)> typeNoRet;
};
template<typename R, typename cls, typename ...Args>
struct function_traits<R(cls::*)(Args...)>
{
typedef R result_type;
typedef typename std::function<R(Args...)> type;
typedef typename std::function<void(Args...)> typeNoRet;
};
要实现类型擦除，我们需要不是模板的基类和派生的模板类。 FunctionHolder将存储基类指针。构造函数将使用 function_traits确定正确的派生类类型。
class FunctionHolder {
private:
struct BaseHolder {
BaseHolder() {}
virtual ~BaseHolder() {}
};
template <typename T>
struct Holder : public BaseHolder {
Holder(T arg) : mFptr(arg) {}
template<typename... Args>
void Call(Args&&...args) {
mFptr(std::forward<Args>(args)...);
}
template<typename R, typename... Args>
R CallRet(Args&&...args) {
return mFptr(std::forward<Args>(args)...);
}
T mFptr;
};
public:
template<typename T>
FunctionHolder(T t) : mBaseHolder(new Holder<typename function_traits<T>::type>(t))
, mBaseHolderNoRet(new Holder<typename function_traits<T>::typeNoRet>(t)) {}
template<typename T, typename...Args>
FunctionHolder(T&& t, Args&&... args) : mBaseHolder(new Holder<typename function_traits<T>::type>
(std::bind(std::forward<T>(t), std::forward<Args>(args)...)))
, mBaseHolderNoRet(new Holder<typename function_traits<T>::typeNoRet>
(std::bind(std::forward<T>(t), std::forward<Args>(args)...))) {}
void operator()() {
this->operator()<>();
}
template<typename... Args>
void operator()(Args&&... args) {
auto f = dynamic_cast<Holder<std::function < void(Args...) > >*>(mBaseHolderNoRet.get());
if (f) {
f->Call(std::forward<Args>(args)...);
return;
}
throw std::invalid_argument("");
}
template<typename R, typename... Args>
R call(Args&&... args) {
auto f = dynamic_cast<Holder<std::function<R(Args...)>>*>(mBaseHolder.get());
if (f) {
return f->template CallRet<R>(std::forward<Args>(args)...);
}
throw std::invalid_argument("");
}
private:
std::unique_ptr<BaseHolder> mBaseHolder;
std::unique_ptr<BaseHolder> mBaseHolderNoRet;
};
在这种情况下，FunctionHolder存储BaseHolder的2个指针，第一个具有正确的签名，第二个返回void。为了避免间接费用，如果您要始终指定返回值或从不使用返回值，则可以删除其中之一。
最后我们可以像这样使用它。
struct st0 {
st0(int x) : mX(x) {}
std::string print(int p) {
std::cout << "st0::print "
<< mX << " " << p << std::endl;
return "ret_from_st0::print";
}
int mX;
};
struct st1 {
st1(int x) : mX(x) {}
void operator()() {
std::cout << "st1::operator() "
<< mX << " " << std::endl;
}
int mX;
};
void Func0(int a, int b) {
std::cout << "Func0. "
<< " a: " << a
<< " b: " << b << std::endl;
}
void Func1(int a, int b, std::string str) {
std::cout << "Func0. "
<< " a: " << a
<< " b: " << b
<< " str: " << str << std::endl;
}
uint64_t Func2(int a, int b, std::string str) {
std::cout << "Func0. "
<< " a: " << a
<< " b: " << b
<< " str: " << str << std::endl;
return 0xBAB0CAFE;
}
int main() {
try {
// void(int, int)
FunctionHolder ex1(&Func0);
ex1(1,12);
// void(int, int, std::string)
FunctionHolder ex2(&Func1);
ex2(1, 12, std::string("Some text here"));
// int(int, int, std::string)
// call and print return value
FunctionHolder ex3(&Func2);
std::cout << "Ret: " << std::hex << ex3.call<uint64_t>(123, 3211, std::string("another text"))
<< std::dec << std::endl;
// call and drop return value
ex3(123, 3211, std::string("another text"));
// Hold std::function<void(int)>
std::function<void(int)> ex4 = std::bind(&Func0, 1, std::placeholders::_1);
FunctionHolder c(std::function<void(int)>(std::bind(&Func0, 1, std::placeholders::_1)));
ex4(12);
// will bind to st0 member function print
st0 st0object(8955);
FunctionHolder ex5(&st0::print, st0object, std::placeholders::_1);
ex5(2222);
// call and print return value
std::cout << "Ret: " << ex5.call<std::string>(7531) << std::endl;
// wrap lambda function with std::function and pass to holder
FunctionHolder ex6(std::function<void(void)>([]() {std::cout << "lambda function called" << std::endl;}));
ex6();
// functor object st1
FunctionHolder ex7(st1(123654));
ex7();
// Will throw, because st1::operator() gets no arguments
ex7(123);
} catch (std::invalid_argument &e) {
std::cout << "Invalid argument(s) were passed" << std::endl;
// error handling here...
}
return 0;
}
FunctionHolder可以存储C之类的函数指针，函子对象，lambda函数和成员函数指针。 要记住的只有两个例外。
FunctionHolder fh(std::function<void(std::string)>(std::bind(&Func1, 888, 333, std::placeholders::_1)));
fh(std::string("Ok."));
如果传递了错误的参数，FunctionHolder将抛出std :: invalid_argument。