C 结构中的运行时条件字段

Question

我有一个用 C 语言编写的特定应用程序，需要提高内存效率。它正在收集统计信息，因此我需要能够在运行时“打开/关闭”某些字段以最小化内存消耗。 我知道您可以使用宏定义条件结构字段，但如果我没记错的话，那是编译时，有没有可能的方法在 C 中在运行时执行此操作？

例子：

输入：

collect (A,B)

会产生这样的结构：

struct statistics{
double A;
double B;
};

但输入：

collect (A,B,C)

会产生这样的结构：

struct statistics{
double A;
double B;
double C;
};

Answer 1

无法在运行时关闭结构内的某些字段。但是，您可以拥有一个指向动态分配的双精度数组的指针，该数组可以表示多个字段。 例如：

#include <stdio.h>
#include <stdlib.h>

struct stats
{
    size_t number_of_doubles;
    double* data;
};

void make_stats(struct stats* pStats)
{
    pStats->number_of_doubles = 3;
    pStats->data = (double*) malloc(pStats->number_of_doubles * sizeof(double));
}

void delete_stats(struct stats* pStats)
{
    free(pStats->data);
}

int main()
{
    struct stats foo;

    make_stats(&foo);

    foo.data[0] = 3.0;
    foo.data[1] = 5.0;
    foo.data[2] = 7.0;

    delete_stats(&foo);    
    return 0;
}

Answer 2

没有办法在运行时改变结构的大小。每当您在堆栈或堆上分配它们时，结构的大小都会内置到可执行文件的指令中。再举一个例子，结构的sizeof 在编译时可用，因此在运行时不能更改。

当然，您可以使用带有自定义内存管理器的自定义结构来执行此操作，但它并未直接内置于语言中。

Answer 3

而不是通常的结构数组（AoS）：

struct statistics{
    double A;
    double B;
    double C;
};

struct statistics my_statistics = malloc(1000000 * sizeof(my_statistics[0]));

my_statistics[0].A = 1;
my_statistics[0].B = 2;
my_statistics[0].C = 3;

您可以切换到数组结构 (SoA)：

struct statistics{
    double *A;
    double *B;
    double *C;
};

struct statistics my_statistics;

my_statistics.A = using_A ? malloc(1000000 * sizeof(my_statistics.A[0])) : NULL;
my_statistics.B = using_B ? malloc(1000000 * sizeof(my_statistics.B[0])) : NULL;
my_statistics.C = using_C ? malloc(1000000 * sizeof(my_statistics.C[0])) : NULL;

my_statistics.A[0] = 1;
my_statistics.B[0] = 2;
my_statistics.C[0] = 3;