C++ 具有不同数据类型或参数的不同函数的函数指针

我有一段代码，它使用一个函数指针指向3点函数sum，subtract，mul。它工作得很好。但现在的问题是，我有不同数量的参数和不同的数据类型的函数。如何实现这一点

int add(int a, int b)
{
    cout<<a+b;
}
int subtract(int a, int b)
{
    cout<<a-b;
}
int mul(int a, int b)
{
    cout<<a*b;
}

int main()
{

    int (*fun_ptr_arr[])(int, int) = {add, subtract, mul};
    unsigned int ch, a = 15, b = 10,c=9;
    ch=2;
    if (ch > 4) return 0;

    (*fun_ptr_arr[ch])(a, b);

    return 0;
}

intadd（inta，intb）
{
cout简单的答案是，从技术上讲，你不能这样做。你可以使用数组作为所有这些函数的输入来进行一些操作，但你仍然需要确切地知道传递给每个函数的内容。从软件工程的角度来看，你不应该这样做-我建议你看看这里的好答案：
simp答案是，从技术上讲，你不能这样做。你可以使用数组作为所有这些函数的输入来进行一些操作，但你仍然需要确切地知道传递给每个函数的内容。从软件工程的角度来看，你不应该这样做-我建议你看看这里的好答案：
如果你有以下内容ng功能

int f1(int i);
int f2(int i, int j);

您可以像这样定义泛型函数类型

typedef int (*generic_fp)(void);

然后初始化函数数组

generic_fp func_arr[2] = {
    (generic_fp) f1,
    (generic_fp) f2
};

但是您必须将函数向后转换

int result_f1 = ((f1) func_arr[0]) (2);
int result_f2 = ((f2) func_arr[1]) (1, 2);

显然，这看起来不是构建程序的好方法

为了使代码看起来更好一点，可以定义宏

#define F1(f, p1) ((f1)(f))(p1)
#define F2(f, p1, p2) ((f2)(f))(p1, p2)

int result_f1 = F1(func_arr[0], 2);
int result_f2 = F2(func_arr[1], 1, 2);

编辑

忘了提一下，您还必须为每种类型的函数定义一个类型

typedef int (*fi)(int); // type for function of one int param
typedef int (*fii)(int, int); // type for function of two int params

然后将存储的指针强制转换到这些类型

int result_f1 = ((fi) func_arr[0]) (2);
int result_f2 = ((fii) func_arr[1]) (1, 2);

这是一个完整的例子

#include <iostream>

typedef int (*generic_fp)(void);
typedef int (*fi)(int); // type for function of one int param
typedef int (*fii)(int, int); // type for function of two int params

#define F1(f, p1) ((fi)(f))(p1)
#define F2(f, p1, p2) ((fii)(f))(p1, p2)

int f1(int i);
int f2(int i, int j);

int main()
{

    generic_fp func_arr[2] = {
        (generic_fp) f1,
        (generic_fp) f2
    };

    int result_f1_no_macro = ((fi) func_arr[0]) (2);
    int result_f2_no_macro = ((fii) func_arr[1]) (1, 2);


    int result_f1_macro = F1(func_arr[0], 2);
    int result_f2_macro = F2(func_arr[1], 1, 2);

    std::cout << result_f1_no_macro << ", " << result_f2_no_macro << std::endl;
    std::cout << result_f1_macro << ", " << result_f2_macro << std::endl;

    return 0;
}

int f1(int i)
{
    return i * 2;
}

int f2(int i, int j)
{
    return i + j;
}

如果您具有以下功能

int f1(int i);
int f2(int i, int j);

您可以像这样定义泛型函数类型

typedef int (*generic_fp)(void);

然后初始化函数数组

generic_fp func_arr[2] = {
    (generic_fp) f1,
    (generic_fp) f2
};

但是您必须将函数向后转换

int result_f1 = ((f1) func_arr[0]) (2);
int result_f2 = ((f2) func_arr[1]) (1, 2);

显然，这看起来不是构建程序的好方法

为了使代码看起来更好一点，可以定义宏

#define F1(f, p1) ((f1)(f))(p1)
#define F2(f, p1, p2) ((f2)(f))(p1, p2)

int result_f1 = F1(func_arr[0], 2);
int result_f2 = F2(func_arr[1], 1, 2);

编辑

忘了提一下，您还必须为每种类型的函数定义一个类型

typedef int (*fi)(int); // type for function of one int param
typedef int (*fii)(int, int); // type for function of two int params

然后将存储的指针强制转换到这些类型

int result_f1 = ((fi) func_arr[0]) (2);
int result_f2 = ((fii) func_arr[1]) (1, 2);

这是一个完整的例子

#include <iostream>

typedef int (*generic_fp)(void);
typedef int (*fi)(int); // type for function of one int param
typedef int (*fii)(int, int); // type for function of two int params

#define F1(f, p1) ((fi)(f))(p1)
#define F2(f, p1, p2) ((fii)(f))(p1, p2)

int f1(int i);
int f2(int i, int j);

int main()
{

    generic_fp func_arr[2] = {
        (generic_fp) f1,
        (generic_fp) f2
    };

    int result_f1_no_macro = ((fi) func_arr[0]) (2);
    int result_f2_no_macro = ((fii) func_arr[1]) (1, 2);


    int result_f1_macro = F1(func_arr[0], 2);
    int result_f2_macro = F2(func_arr[1], 1, 2);

    std::cout << result_f1_no_macro << ", " << result_f2_no_macro << std::endl;
    std::cout << result_f1_macro << ", " << result_f2_macro << std::endl;

    return 0;
}

int f1(int i)
{
    return i * 2;
}

int f2(int i, int j)
{
    return i + j;
}

使用对象实现所需行为的一种稍有不同的方法。为了获得真正通用的解决方案，我们需要使用
接口
。
拆除数据和操作，即分开保存

//Interface which describes any kind of data.
struct IData
{
        virtual ~IData()
        {
        }
};

//Interface which desribes any kind of operation
struct IOperation
{
        //actual operation which will be performed
        virtual IData* Execute(IData *_pData) = 0;

        virtual ~IOperation()
        {
        }
};

现在，每个操作都知道它所处理的数据的类型，并且只希望看到这种类型的数据

struct Operation_Add : public IOperation
{
            //data for operation addition.
            struct Data : public IData
            {
                    int a;
                    int b;
                    int result;
            };

            IData* Execute(IData *_pData)
            {
                    //expected data is "Operation_Add::Data_Add"
                    Operation_Add::Data *pData = dynamic_cast<Operation_Add::Data*>(_pData);
                    if(pData == NULL)
                    {
                            return NULL;
                    }

                    pData->result = pData->a + pData->b;
                    return pData;
            }
};

struct Operation_Avg : public IOperation
{
            //data for operation average of numbers.
            struct Data : public IData
            {
                    int a[5];
                    int total_numbers;
                    float result;
            };

            IData* Execute(IData *_pData)
            {
                    //expected data is "Operation_Avg::Data_Avg"
                    Operation_Avg::Data *pData = dynamic_cast<Operation_Avg::Data*>(_pData);
                    if(pData == NULL)
                    {
                            return NULL;
                    }

                    pData->result = 0.0f;
                    for(int i = 0; i < pData->total_numbers; ++i)
                    {
                            pData->result += pData->a[i];
                    }
                    pData->result /= pData->total_numbers;
                    return pData;
            }
};

struct操作\u添加：公共操作
{
//用于操作添加的数据。
结构数据：公共IData
{
INTA；
int b；
int结果；
};
IData*执行（IData*\u pData）
{
//预期数据为“操作添加：：数据添加”
操作添加：：数据*pData=dynamic\u cast（\u pData）；
if（pData==NULL）
{
返回NULL；
}
pData->result=pData->a+pData->b；
返回pData；
}
};
结构操作\u平均值：公共操作
{
//数字操作平均值的数据。
结构数据：公共IData
{
int a[5]；
整数总数；
浮动结果；
};
IData*执行（IData*\u pData）
{
//预期数据为“操作平均值：：数据平均值”
操作平均值：：数据*pData=动态转换（_pData）；
if（pData==NULL）
{
返回NULL；
}
pData->result=0.0f；
对于（int i=0；itotal_numbers；++i）
{
pData->result+=pData->a[i]；
}
pData->result/=pData->总数；
返回pData；
}
};

这里是操作处理器，CPU

struct CPU
{
            enum OPERATION
            {
                    ADDITION = 0,
                    AVERAGE
            };

            Operation_Add m_stAdditionOperation;
            Operation_Avg m_stAverageOperation;
            map<CPU::OPERATION, IOperation*> Operation;

            CPU()
            {
                    Operation[CPU::ADDITION] = &m_stAdditionOperation;
                    Operation[CPU::AVERAGE] = &m_stAverageOperation;
            }
};

结构CPU
{
枚举操作
{
加法=0，
平均值
};
操作添加操作；
平均运行时间；
地图操作；
CPU（）
{
操作[CPU:：加法]=&m_stationOperation；
操作[CPU:：AVERAGE]=&m_平均操作；
}
};

示例：

    CPU g_oCPU;

    Operation_Add::Data stAdditionData;
    stAdditionData.a = 10;
    stAdditionData.b = 20;

    Operation_Avg::Data stAverageData;
    stAverageData.total_numbers = 5;
    for(int i = 0; i < stAverageData.total_numbers; ++i)
    {
            stAverageData.a[i] = i*10;
    }

    Operation_Add::Data *pResultAdd = dynamic_cast<Operation_Add::Data*>(g_oCPU.Operation[CPU::ADDITION]->Execute(&stAdditionData));
    if(pResultAdd != NULL)
    {
            printf("add = %d\n", pResultAdd->result);
    }

    Operation_Avg::Data *pResultAvg = dynamic_cast<Operation_Avg::Data*>(g_oCPU.Operation[CPU::AVERAGE]->Execute(&stAverageData));
    if(pResultAvg != NULL)
    {
            printf("avg = %f\n", pResultAvg->result);
    }

cpugocpu；
操作添加：：数据状态添加数据；
statadditiondata.a=10；
statadditiondata.b=20；
操作平均值：：数据平均值数据；
StataverageData.total_数=5；
对于（int i=0；i执行（&statdditiondata））；
如果（预加！=NULL）
{
printf（“添加=%d\n”，预添加->结果）；
}
Operation_Avg:：Data*presltavg=dynamic_cast（g_oCPU.Operation[CPU:：AVERAGE]->执行（&stataveragedata））；
如果（预设值！=NULL）
{
printf（“平均值=%f\n”，预设值->结果）；
}

使用对象实现所需行为的方法略有不同。为了获得真正通用的解决方案，我们需要使用

接口。
拆除数据和操作，即分开保存

//Interface which describes any kind of data.
struct IData
{
        virtual ~IData()
        {
        }
};

//Interface which desribes any kind of operation
struct IOperation
{
        //actual operation which will be performed
        virtual IData* Execute(IData *_pData) = 0;

        virtual ~IOperation()
        {
        }
};

现在，每个操作都知道它所处理的数据的类型，并且只希望看到这种类型的数据

struct Operation_Add : public IOperation
{
            //data for operation addition.
            struct Data : public IData
            {
                    int a;
                    int b;
                    int result;
            };

            IData* Execute(IData *_pData)
            {
                    //expected data is "Operation_Add::Data_Add"
                    Operation_Add::Data *pData = dynamic_cast<Operation_Add::Data*>(_pData);
                    if(pData == NULL)
                    {
                            return NULL;
                    }

                    pData->result = pData->a + pData->b;
                    return pData;
            }
};

struct Operation_Avg : public IOperation
{
            //data for operation average of numbers.
            struct Data : public IData
            {
                    int a[5];
                    int total_numbers;
                    float result;
            };

            IData* Execute(IData *_pData)
            {
                    //expected data is "Operation_Avg::Data_Avg"
                    Operation_Avg::Data *pData = dynamic_cast<Operation_Avg::Data*>(_pData);
                    if(pData == NULL)
                    {
                            return NULL;
                    }

                    pData->result = 0.0f;
                    for(int i = 0; i < pData->total_numbers; ++i)
                    {
                            pData->result += pData->a[i];
                    }
                    pData->result /= pData->total_numbers;
                    return pData;
            }
};

struct操作\u添加：公共操作
{
//用于操作添加的数据。
结构数据：公共IData
{
INTA；
int b；
int结果；
};
IData*执行（IData*\u pData）
{
//预期数据为“操作添加：：数据添加”
操作工