C - 多态（void *）数组

Question

我最近试图找出使用void * 数组而不是典型类型（int、char 等）的好处。所以我尝试编写一个多态 (void *) 函数，它接受任何类型数据的 3 个数组 (a, b, c) 作为参数，并在数组 a 和 b 的每个节点之间进行计算，并将结果放入数组 @ 987654329@。计算的类型（sum、sub 等）和要计算的数据类型取决于用户（也许我们可以为函数使用另外两个参数）。

所以我的函数原型如下所示：

void *apply(void *a, void *b, void *c, int calc, int typeOfCalc);

我无法理解如何使用每个 void 数组的内容，具体取决于其类型，以及如何根据用户想要的数据类型进行计算。

编辑

我找到了一个练习，它问的问题和我一样，并说：

编写一个多态函数"apply"，其参数相同 任何（每种）类型的元素的尺寸表（a，b，c），使 a [i] b [i] 之间的事务对于每个 i 并将结果 对 c[i] 采取行动。行为和结果将产生，被确定 调用者函数。

Answer 1

您可以使用函数指针而不是 typeOfCalc，它接收 a、b 和 c。因此，如果您想对浮点数求和，则传递一个“sumFloat”指针。您还可以将大量函数指针（sum、product 等）存储在结构中（例如，“operationsFloat”）并传递它。一些代码说明：

void sumFloat(void *a, void *b, void *c)
{
    float * f_a = a;
    float * f_b = b;
    float * f_c = c;

    *c = *a + *b;
}

void productFloat(void *a, void *b, void *c)
{
    float * f_a = a;
    float * f_b = b;
    float * f_c = c;

    *c = *a * *b;
}

typedef struct{
    void (*sum)(void *a, void *b, void *c);
    void (*product)(void *a, void *b, void *c);
}Operations;

Operations operationsFloat = {
        .sum = sumFloat,
        .product = productFloat,
};

void apply(void *a, void *b, void *c, char op, Operations * opClass){
    switch (op) {
        case '+':
            opClass->sum(a, b, c);
            break;
        case '*':
            opClass->product(a, b, c);
            break;
        default:
            break;
    }
}

Answer 2

这里是一个获取任意类型数组并使用回调函数的示例：

#include <stdio.h>

enum OP{SUM, SUB};

void calc_int(const void *pa, const void *pb, void *pc, enum OP op)
{
    switch (op) {
        case SUM:
            *(int *)pc = *(const int *)pa + *(const int *)pb;
            break;
        case SUB:
            *(int *)pc = *(const int *)pa - *(const int *)pb;
            break;
    }
}

void calc_double(const void *pa, const void *pb, void *pc, enum OP op)
{
    switch (op) {
        case SUM:
            *(double *)pc = *(const double *)pa + *(const double *)pb;
            break;
        case SUB:
            *(double *)pc = *(const double *)pa - *(const double *)pb;
            break;
    }
}

void calc(void *pa, void *pb, void *pc, size_t n, size_t size, enum OP op,
          void (cb)(const void *, const void *, void *, enum OP))
{
    char *a = (char *)pa;
    char *b = (char *)pb;
    char *c = (char *)pc;
    size_t i;

    for (i = 0; i < n; i++) {
        cb(a, b, c, op);
        a += size;
        b += size;
        c += size;
    }
}

int main(void)
{
    #define N 3
    int ia[N] = {1, 2, 3};
    int ib[N] = {4, 5, 6};
    int ic[N];
    double da[N] = {4., 5., 6.};
    double db[N] = {1., 2., 3.};
    double dc[N];
    int i;

    calc(ia, ib, ic, N, sizeof(*ia), SUM, calc_int);
    calc(da, db, dc, N, sizeof(*da), SUB, calc_double);

    for (i = 0; i < N; i++) {
        printf("ic[%d] = %d\n", i, ic[i]);
    }
    for (i = 0; i < N; i++) {
        printf("dc[%d] = %f\n", i, dc[i]);
    }   
    return 0;
}