我正在努力实现一个函数，该函数将来会在几秒钟内执行另一个函数，具体取决于用户的输入。我有一个类的优先级队列（我正在调用TimedEvent），它包含一个函数指针，指向我希望它在间隔结束时执行的操作。比如说用户希望程序在3秒后调用函数“xyz”，他们会创建一个新的TimedEvent，其时间和函数指针指向xyz并将其添加到优先级队列（按时间排序，使用最快的事件发生在第一位。）
我已经能够成功获得优先级队列以在指定时间后弹出顶部元素，但是我在这里碰到了一堵墙。我想调用的函数可以采用各种不同的参数，从只有一个整数的函数到带有3个整数的函数，一个字符串等，并返回不同的值（一些整数，一些字符串等）。我已经研究了va_lists（我没有经验），但这似乎不是答案，除非我遗漏了什么。
总结（ TL; DR 版本）：
我希望能够使用相同的函数指针将这些函数称为“多样化”：
void func1(int a, int b);<br/>
int func2(int a, string b, OtherClass c);
我是否在使用va_list和函数回调的正确轨道上？这可以轻松（或根本）实施吗？
谢谢！
答案 0 :(得分：3)
我在这里推断这些函数是您无法控制的API调用。我讨厌了一些我认为或多或少会影响你的东西;这是一种粗略的命令模式。
#include <iostream>
#include <string>
using namespace std;
//these are the various function types you're calling; optional
typedef int (*ifunc)(const int, const int);
typedef string (*sfunc)(const string&);
// these are the API functions you're calling
int func1(const int a, const int b) { return a + b; }
string func2(const string& a) { return a + " world"; }
// your TimedEvent is given one of these
class FuncBase
{
public:
virtual void operator()() = 0;
};
// define a class like this for each function type
class IFuncWrapper : public FuncBase
{
public:
IFuncWrapper(ifunc fp, const int a, const int b)
: fp_(fp), a_(a), b_(b), result_(0) {}
void operator()() {
result_ = fp_(a_, b_);
}
int getResult() { return result_; }
private:
ifunc fp_;
int a_;
int b_;
int result_;
};
class SFuncWrapper : public FuncBase
{
public:
SFuncWrapper(sfunc fp, const string& a)
: fp_(fp), a_(a), result_("") {}
void operator()() {
result_ = fp_(a_);
}
string getResult() { return result_; }
private:
sfunc fp_;
string a_;
string result_;
};
int main(int argc, char* argv[])
{
IFuncWrapper ifw(func1, 1, 2);
FuncBase* ifp = &ifw;
// pass ifp off to your TimedEvent, which eventually does...
(*ifp)();
// and returns.
int sum = ifw.getResult();
cout << sum << endl;
SFuncWrapper sfw(func2, "hello");
FuncBase* sfp = &sfw;
// pass sfp off to your TimedEvent, which eventually does...
(*sfp)();
// and returns.
string cat = sfw.getResult();
cout << cat << endl;
}
如果你有很多函数返回相同的类型，你可以定义一个FuncBase的子类来实现相应的GetResult（），这些函数的包装器可以对它进行子类化。返回void的函数当然不需要在包装类中使用GetResult（）。
答案 1 :(得分：3)
我认为boost::bind对您有用。对于您的应用程序，您可能希望在创建仿函数之前绑定所有参数，然后再将其放入队列（即，不使用任何_1或_2占位符）。我认为你不需要像lambda expressions/abstractions那样复杂的东西，但是理解它们是什么很好。
+1首席执行官的DIY方法。这也会奏效，但你必须自己做所有艰苦的工作。
如果您想DIY，我建议使用模板而不是为每种类型的组合定义xfunc和XFuncWrapper（参见下面的代码）。
此外，我认为允许不同的返回类型将是毫无意义的 - 无论代码是否出队并且调用函数将是通用的。它要么从每个函数中获得相同类型的返回，要么它们期望它们是过程（返回void）。
template<typename R>
class FuncWrapper0 : public FuncBase
{
public:
typedef R (*func)();
FuncWrapper0(func fp) : fp_(fp) { }
void operator()() { result_ = fp_(); }
R getResult() { return result_; }
private:
func fp_;
R result_;
};
template<typename R, typename P1>
class FuncWrapper1 : public FuncBase
{
public:
typedef R (*func)(const P1 &);
FuncWrapper1(func fp, const P1 &p1) : fp_(fp), p1_(p1) { }
void operator()() { result_ = fp_(p1_); }
R getResult() { return result_; }
private:
func fp_;
P1 p1_;
R result_;
};
template<typename R, typename P1, typename P2>
class FuncWrapper2 : public FuncBase
{
public:
typedef R (*func)(const P1 &, const P2 &);
FuncWrapper2(func fp, const P1 &p1, const P2 &p2)
: fp_(fp), p1_(p1), p2_(p2) { }
void operator()() { result_ = fp_(p1_, p2_); }
R getResult() { return result_; }
private:
func fp_;
P1 p1_;
P2 p2_;
R result_;
};
答案 2 :(得分：1)
你要做的事几乎不可能去上班。您可能需要考虑将参数打包为类似std::vector<boost::any>的内容。
变量参数列表实际上与您想要的相反。变量参数列表允许从多个站点调用单个函数，每个站点都有一组唯一的参数。你想要的是从一个站点调用多个函数，每个函数都有一组唯一的参数 - 而变量参数列表不支持它。
答案 3 :(得分：1)
c/invoke是一个允许你在运行时构造任意函数调用的库，但我认为在这种情况下这样做太过分了。听起来你应该找到一种方法来“规范化”回调函数的签名，这样你每次都可以用一个列表，结构，联合或者允许你通过同一个接口传递不同数据的东西来调用它。
答案 4 :(得分：1)
好吧，有一个真正的硬核技巧可以利用这样一个事实：在C中，每个函数都是一个指针，你可以将指针强制转换为任何其他指针。原始代码，我从中得到了这个代码，当编译器没有给出隐式转换时出错时，所以我花了一段时间才弄明白我必须抛出这些函数。它的作用是将回调函数强制转换为具有可变数量参数的函数。但与此同时，调用函数被强制转换为具有10个参数的函数，其中并非所有参数都将被提供。特别是这最后一步看起来很棘手，但你之前已经看过了，你给printf提供了错误数量的参数，它只是编译。甚至可能是这就是va_start / va_end在幕后所做的事情。该代码实际上是用于对数据库中的任何元素执行自定义操作，但它也可以用于您的情况：
#include <stdio.h>
typedef int (*INTFUNC)(int,...);
typedef int (*MAPFUNCTION)(int [], INTFUNC, ...);
//------------------CALLBACK FUNCTION----------------
static int callbackfunction(int DatabaseRecord,int myArgument,int *MyResult){
if(DatabaseRecord < myArgument){
printf("mapfunction record:%d<%d -> result %d+%d=%d\n",DatabaseRecord,myArgument,*MyResult,DatabaseRecord,*MyResult+DatabaseRecord);
*MyResult+=DatabaseRecord;}
else{
printf("mapfunction record:%d<%d not true\n",DatabaseRecord,myArgument);
}
return 0; // keep looping
}
//------------------INVOCATION FUNCTION---------------
static int MapDatabase(int DataBase[], INTFUNC func, void* a1, void* a2, void* a3, void* a4, void* a5, void* a6, void* a7, void* a8, void* a9)
{
int cnt,end;
int ret = 0;
end = DataBase[0]+1;
for(cnt = 1;cnt<end;++cnt){
if(func(DataBase[cnt], a1, a2, a3, a4, a5, a6, a7, a8, a9)) {
ret = DataBase[cnt];
break;
}
}
return ret;
}
//------------------TEST----------------
void TestDataBase3(void)
{
int DataBase[20];
int cnt;
int RecordMatch;
int Result = 0;
DataBase[0] = 19;
for(cnt = 1;cnt<20;++cnt){
DataBase[cnt] = cnt;}
// here I do the cast to MAPFUNCTION and INTFUNC
RecordMatch = ((MAPFUNCTION)MapDatabase)(DataBase,(INTFUNC)callbackfunction,11,&Result);
printf("TestDataBase3 Result=%d\n",Result);
}
使用va_start / va_end可以完美地编写相同的功能。它可能是更正式的做事方式，但我发现它不那么用户友好。回调函数需要解码其参数，或者您需要在调用函数内为回调函数可以具有的每个参数组合编写一个switch / case块。这意味着您必须提供参数的格式（就像printf一样）或者您必须要求所有参数都相同并且您只提供参数的数量，但是您仍然必须为每个金额写一个案例论点。以下是回调函数对参数进行解码的示例：
#include <stdio.h>
#include <stdarg.h>
//------------------CALLBACK FUNCTION----------------
static int callbackfunction(int DatabaseRecord,va_list vargs)
{
int myArgument = va_arg(vargs, int); // The callbackfunction is responsible for knowing the argument types
int *MyResult = va_arg(vargs, int*);
if(DatabaseRecord < myArgument){
printf("mapfunction record:%d<%d -> result %d+%d=%d\n",DatabaseRecord,myArgument,*MyResult,DatabaseRecord,*MyResult+DatabaseRecord);
*MyResult+=DatabaseRecord;}
else{
printf("mapfunction record:%d<%d not true\n",DatabaseRecord,myArgument);
}
return 0; // keep looping
}
//------------------INVOCATION FUNCTION---------------
static int MapDatabase(int DataBase[], int (*func)(int,va_list), int numargs, ...)
{
int cnt,end;
int ret = 0;
va_list vargs;
end = DataBase[0]+1;
for(cnt = 1;cnt<end;++cnt){
va_start( vargs, numargs ); // needs to be called from within the loop, because va_arg can't be reset
if(func(DataBase[cnt], vargs)) {
ret = DataBase[cnt];
break;
}
va_end( vargs ); // avoid memory leaks, call va_end
}
return ret;
}
//------------------TEST----------------
void TestDataBase4(void)
{
int DataBase[20];
int cnt;
int RecordMatch;
int Result = 0;
DataBase[0] = 19;
for(cnt = 1;cnt<20;++cnt){
DataBase[cnt] = cnt;}
RecordMatch = MapDatabase(DataBase,callbackfunction,2,11,&Result);
printf("TestDataBase4a Result=%d\n",Result);
Result = 0;
RecordMatch = MapDatabase(DataBase,callbackfunction,0,11,&Result); // As a hack: It even works if you don't supply the number of arguments.
printf("TestDataBase4b Result=%d\n",Result);
}
答案 5 :(得分：1)
@Redef，如果你的编译器将args优化为寄存器，除非它们是vargs，否则不需要将它们压入堆栈。这意味着，在您的第一个示例中，回调函数将期望寄存器中的args，而使用INTFUNC（具有vargs decl）的调用者将它们推入堆栈。
结果将是回调没有看到args。