具有函数指针的C ++模板设计

Question

我对C ++有点陌生，请让我描述一下我的问题。 我有一个称为CSubcriber的类，其主要目的是执行某些类型和数量的参数的回调函数。 例如，回调可以是：

typedef void (*cb1)(void)
typedef int (*cb2)(int, int)
typedef char (*cb3)(int, int, void);

类本身是：

template <class CallbackType>

class CSubscriber {
public:
    CSubscriber();
    virtual ~CSubscriber();
    CallbackType (*m_callback_newWay)(void *params);
    void (*m_callback)(void *params);
    int (*m_callback_int)(void *params);
    void *m_cb_params;
    int execute_cb();
    void *m_params;

    CSubscriber(void (*callback)(void *params), void *cb_params);
    CSubscriber(int (*callback)(void *params), void *cb_params);

};

CSubscriber::CSubscriber(void (*callback)(void *params), void *cb_params){
    m_callback = callback;
    m_cb_params = cb_params;
}

CSubscriber::CSubscriber(int (*callback)(void *params), void *cb_params){
    m_callback_int = callback;
    m_cb_params = cb_params;
}

我现在的主要问题是如何编写构造函数，该构造函数将处理所有具有可变参数的回调。 在某个特定时刻构造对象之后，可能会触发回调，例如：

typedef int (*callback)(void *params);
CSubscriber s(callback, params);

要么

typedef void (*callback2)(void *params, int arr, char *ptr);
CSubscriber s(callback, params, arr, ptr);

现在，打电话

s->m_callback()

我想用传递给构造函数的所有参数执行回调。 我想避免为传递给回调函数的每个不同数量的参数编写十个不同的构造函数。 有可能吗？

Answer 1

尝试这样的事情。

#include <iostream>

using namespace std;

typedef void (*cb1)(void);
typedef int (*cb2)(int, int);
typedef char (*cb3)(int, int, char);

template <class CallbackType>
class CSubscriber
{
public:
    CSubscriber(): fcn1(0), fcn2(0), fcn3(0) {};
    virtual ~CSubscriber(){};

    CSubscriber(cb1 fcn): fcn1(fcn), fcn2(0), fcn3(0), a(), b() {};
    CSubscriber(cb2 fcn, int p1, int p2): fcn1(0), fcn2(fcn), fcn3(0), a(p1), b(p2)  {};

    int execute_cb() {
        if ( fcn1 != 0 ) {
            (*fcn1)();
        }
        if ( fcn2 != 0 ) {
            (*fcn2)(a,b);
        }
    };

protected:
    cb1  fcn1;
    cb2  fcn2;
    cb3  fcn3;

    int a, b;
};

void fcn1() {
    cout << "in fcn1" << endl;
};

int fcn2(int a, int b) {
    cout << "in fcn2, a " << a << ", b " << b << endl;
};

int main()
{
    CSubscriber<int> cs;
    CSubscriber<int> cs1(&fcn1);
    CSubscriber<int> cs2(&fcn2, 1, 100);

    cs.execute_cb();
    cs1.execute_cb();
    cs2.execute_cb();
 }