Union vs void 指针性能 [已关闭]

问：

TL;DR 在性能方面比 void 指针更好

当我搜索 Union vs void 指针性能时，我仔细研究了这个问题：Union vs void pointer。 许多人建议使用联合，但都不是因为性能。我的问题是 void 指针是否比 union 花费更多时间，因为我们需要一次又一次地键入 cast。

我写了下面的代码来测试性能，发现联合要好得多。

#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

typedef struct union_test union_test;
typedef struct void_test void_test;
typedef void (*PrintUnionFunction)(union_test *);
typedef void (*PrintVoidFunction)(void_test *);

typedef enum ELEM_TYPE
{
    INT_TYPE,
    STRING_TYPE,
    FLOAT_TYPE
} ELEM_TYPE;

struct union_test
{
    ELEM_TYPE elemType;
    union {
        int **intElems;
        float **floatElems;
        char **stringElems;
    };
    size_t elemCount;
    PrintUnionFunction printFunction;
};

struct void_test
{
    ELEM_TYPE elemType;
    void **elems;
    size_t elemCount;
    PrintVoidFunction printFunction;
};

void printUnionInt(union_test *fpTest)
{
    for (size_t i = 0; i < fpTest->elemCount; i++)
    {
        int *temp = fpTest->intElems[i];
        (*temp)++;
        // printf("%d ", *fpTest->intElems[i]);
    }
}

void printVoidPointerInt(void_test *fpTest)
{
    for (size_t i = 0; i < fpTest->elemCount; i++)
    {
        int *temp = ((int *)fpTest->elems[i]);
        (*temp)++;
        // printf("%d ", *fpTest->intElems[i]);
    }
}

int main()
{
    clock_t start_time_union, end_time_union;
    clock_t start_time_void, end_time_void;
    size_t elemCount = 1024 * 1024 * 1024;

    union_test *fp = (union_test *)malloc(sizeof(union_test));
    fp->elemCount = elemCount;
    fp->elemType = INT_TYPE;
    fp->printFunction = printUnionInt;
    fp->intElems = (int **)malloc(sizeof(int *) * fp->elemCount);

    for (size_t i = 0; i < fp->elemCount; i++)
    {
        fp->intElems[i] = (int *)malloc(sizeof(int));
        memcpy(fp->intElems[i], &i, sizeof(int));
    }

    void_test *void_fp = (void_test *)malloc(sizeof(union_test));
    void_fp->elemCount = elemCount;
    void_fp->elemType = INT_TYPE;
    void_fp->printFunction = printVoidPointerInt;
    void_fp->elems = (void **)malloc(sizeof(void *) * void_fp->elemCount);

    for (size_t i = 0; i < void_fp->elemCount; i++)
    {
        void_fp->elems[i] = (int *)malloc(sizeof(int));
        memcpy(void_fp->elems[i], &i, sizeof(int));
    }

    start_time_union = clock();
    fp->printFunction(fp);
    end_time_union = clock();

    start_time_void = clock();
    void_fp->printFunction(void_fp);
    end_time_void = clock();

    printf("\n\nunion execution time: %f seconds\n", (double)(end_time_union - start_time_union) / CLOCKS_PER_SEC);
    printf("void pointer execution time: %f seconds\n", (double)(end_time_void - start_time_void) / CLOCKS_PER_SEC);

    return 0;
}

我得到了以下结果。

union execution time: 8.237730 seconds
void pointer execution time: 8.647505 seconds

我在某些地方看到使用 -O3 会使编译器永远不会打扰指针类型，并将所有内容视为仅内存字节，但即使使用 -O3 标志，我也找不到任何改进的性能。

注意：我只关心性能，而不关心可读性。我知道，当我们要处理的类型数量有限时，使用联合是提高可读性的好方法。