Question

我有两个结构和const chars数组：

typedef struct {
    int skip_lines;
    int num; // count of files
    int i; // number of the file to define order; extremly important to set correctly and then not to change!
    char filename[70];
    char main_directory[16];
    char submain_directory[100];
} FILE_;

typedef struct {
    FILE_ radiation_insolation[7];
    FILE_ radiation_radiation[5];
    FILE_ winds[9];
    FILE_ pressure[1];
    FILE_ humidity[1];
    FILE_ temperature[4];
} FILES;

char *tables[] = {"radiation_insolation", "radiation_radiation", "winds", "pressure", "humidity", "temperature" };

我在main函数中也有FILES files;并启动从文件加载数据的函数。因此，文件的每个成员都包含数据。

然后我需要访问这样的数据：

files->radiation_insolation[0].skip_lines
files->radiation_radiation[0].skip_lines
files->radiation_winds[0].skip_lines
files->pressure[0].skip_lines
files->humidity[0].skip_lines
files->temperature[0].skip_lines

我的计划是创建循环来动态处理每个成员。

for(i = 0; i<6; i++) {
        // do some job
    }

我的问题是如何在我需要访问例如files-＆gt; radiation_insolation使用循环中的表[i]？如何创建成员的名称，以便编译器知道要访问的成员？

在PHP语言中，可以使用$ files-＆gt; $ tables [i]之类的东西。但是怎么用C做呢？

Answer 1

答案是你不能。好吧，在真正的C编译器上，您可能能够将第二个结构别名为FILE_的数组，但我很确定它会调用未定义的行为。我认为标准中没有任何内容表示结构中的填充，其中所有成员都是相同的类型必须与所有成员属于同一类型的数组中的填充相同。

如果能够访问单个for语句中的所有成员很重要，那么最好使用实际数组并定义一些常量：

enum {
   radiation_isolation = 0,
   radiation_radiation = 7,
   winds = 12,
   // etc
}

FILE_ files[total_files];

FILE_ *isolation_3 = &files[radiation_isolation + 3];

你可能会编写一些函数来使它看起来更好并提供一些边界检查。

Answer 2

在C语言中没有办法实现这一点。结构不是表格，而是更接近硬件的东西，即内存块。

您可以创建一个icky宏来访问结构：

// bad idea
#define FILES_ITEM(var, field, index, member) var.field[index].member

但是这些宏只是毫无意义和不好的做法，输入所有内容要清楚得多：

int main (void)
{
  FILES files;

  for(size_t i=0; i<7; i++)
  {
    files.radiation_insolation[i].skip_lines = i;
    printf("%d ", files.radiation_insolation[i].skip_lines);
  }
}

除了上述风格之外，通常很难证明其他任何理由。

使用C11，你可以通过使用一个包含匿名结构和数组的联合来改善这种情况：

#define FILE_ITEMS_N (7 + 5 + 9 + 1 + 1 + 4)

typedef union {

  struct
  {
    FILE_ radiation_insolation[7];
    FILE_ radiation_radiation[5];
    FILE_ winds[9];
    FILE_ pressure[1];
    FILE_ humidity[1];
    FILE_ temperature[4];
  };

  FILE_ items [FILE_ITEMS_N];

} FILES;

然后，您可以单独访问成员：

files.radiation_insolation[0].skip_lines = 123;

或作为数组：

files.items[item].skip_lines = 123;

工会保证按照C11§6.7.2.1：

工作

14结构或联合对象的每个非位字段成员都是对齐的   以适合其类型的实现定义方式。

/ - /

17结构或联合的末尾可能有未命名的填充。

这意味着内部结构的所有成员都保证适当地对齐，如果需要，在结构的末尾使用尾部填充。

此外，根据C11 6.5 / 7，阵列也保证对各个成员别名没有问题：

对象的存储值只能由具有其中一个的左值表达式访问   以下类型：

/ - /

- 包含其中一种上述类型的聚合或联合类型   成员（包括递归地，子集合或包含的联合的成员）

Answer 3

union FILES FILE_和类似结构，其中包含所有27个元素中的一个typedef union { FILES f; FILE_ all[27]; } FILES_U;数组：

files->f.radiation_radiation[0]

然后，您可以访问files->all[7]或tables。 all数组将包含item（0,7,12 ...）中的基本索引，而不是字符串名称。

Answer 4

一种方法是通过（ab）使用x-macros。它们可以让你减少重复，同时牺牲你同事的潜在愤怒。好处是您只需要在一个地方更新项目列表，预处理器将自动生成结构和所有必需的元数据。

即。你只需定义一个像这样的条目列表，其中FILE_ENTRY尚未定义：

#define X_FILE_LIST(X_FILE_ENTRY) \
    X_FILE_ENTRY(radiation_insolation, 7) \
    X_FILE_ENTRY(radiation_radiation, 5) \
    X_FILE_ENTRY(winds, 9) \
    X_FILE_ENTRY(pressure, 1) \
    X_FILE_ENTRY(humidity, 1) \
    X_FILE_ENTRY(temperature, 4)

然后根据需要定义FILE_ENTRY(name, len)：

// number of entries
#define X_EXPAND_AS_COUNT(name, len) 1 + 
const int FILES_count = X_FILE_LIST(X_EXPAND_AS_COUNT) 0;

// struct definition
#define X_EXPAND_AS_FIELD(name, len) FILE_ name[len];
typedef struct {
    X_FILE_LIST(X_EXPAND_AS_FIELD)
}
FILES;

// byte offsets of each field
#define X_EXPAND_AS_BYTEOFFSET(name, len) offsetof(FILES, name),
int FILES_byte_offsets[] = {
    X_FILE_LIST(X_EXPAND_AS_BYTEOFFSET)
};

// FILE_ offsets of each field
#define X_EXPAND_AS_FILEOFFSET(name, len) offsetof(FILES, name)/sizeof(FILE_),
int FILES_offsets[] = {
    X_FILE_LIST(X_EXPAND_AS_FILEOFFSET)
};

// sizes of each array
#define X_EXPAND_AS_LEN(name, len) len,
int FILES_sizes[] = {
    X_FILE_LIST(X_EXPAND_AS_LEN)
};

// names of each field
#define X_EXPAND_AS_NAME(name, len) #name,
const char * FILES_names[] = {
    X_FILE_LIST(X_EXPAND_AS_NAME)
};

这将扩展为：

const int FILES_count = 1 + 1 + 1 + 1 + 1 + 1 + 0;

typedef struct {
    FILE_ radiation_insolation[7];
    FILE_ radiation_radiation[5]; 
    FILE_ winds[9]; 
    FILE_ pressure[1]; 
    FILE_ humidity[1]; 
    FILE_ temperature[4];
}
FILES;

int FILES_byte_offsets[] = {
    ((size_t)&(((FILES*)0)->radiation_insolation)),
    ((size_t)&(((FILES*)0)->radiation_radiation)),
    ((size_t)&(((FILES*)0)->winds)),
    ((size_t)&(((FILES*)0)->pressure)),
    ((size_t)&(((FILES*)0)->humidity)),
    ((size_t)&(((FILES*)0)->temperature)),
};

int FILES_offsets[] = {
    ((size_t)&(((FILES*)0)->radiation_insolation))/sizeof(FILE_), 
    ((size_t)&(((FILES*)0)->radiation_radiation))/sizeof(FILE_),
    ((size_t)&(((FILES*)0)->winds))/sizeof(FILE_), 
    ((size_t)&(((FILES*)0)->pressure))/sizeof(FILE_),
    ((size_t)&(((FILES*)0)->humidity))/sizeof(FILE_),
    ((size_t)&(((FILES*)0)->temperature))/sizeof(FILE_),
};

int FILES_sizes[] = { 7, 5, 9, 1, 1, 4, };

const char * FILES_names[] = {
    "radiation_insolation", "radiation_radiation",
    "winds", "pressure", "humidity", "temperature",
};

然后您可以使用以下内容进行迭代：

for (int i = 0; i < FILES_count; i++)
{
    FILE_ * first_entry = (FILE_ *)&files + FILES_offsets[i];
    for (int j = 0; j < FILES_sizes[i]; j++)
    {
        FILE_ * file = first_entry + j;
        printf("%s[%d].skip_lines = %d \n",
            FILES_names[i],
            j,
            file->skip_lines);
    }
}

这将遍历FILES的所有成员，并遍历每个字段的所有数组成员：

// output of the program above
radiation_insolation[0].skip_lines = 0
radiation_insolation[1].skip_lines = 0
radiation_insolation[2].skip_lines = 0
radiation_insolation[3].skip_lines = 0
radiation_insolation[4].skip_lines = 0
radiation_insolation[5].skip_lines = 0
radiation_insolation[6].skip_lines = 0
radiation_radiation[0].skip_lines = 0
radiation_radiation[1].skip_lines = 0
radiation_radiation[2].skip_lines = 0
radiation_radiation[3].skip_lines = 0
radiation_radiation[4].skip_lines = 0
winds[0].skip_lines = 0
winds[1].skip_lines = 0
winds[2].skip_lines = 0
winds[3].skip_lines = 0
winds[4].skip_lines = 0
winds[5].skip_lines = 0
winds[6].skip_lines = 0
winds[7].skip_lines = 0
winds[8].skip_lines = 0
pressure[0].skip_lines = 0
humidity[0].skip_lines = 0
temperature[0].skip_lines = 0
temperature[1].skip_lines = 0
temperature[2].skip_lines = 0
temperature[3].skip_lines = 0

这会带您进入实际的“反射”，它允许您通过其名称找到该成员：

FILE_ * get_entry_by_name_and_index(FILES * files, const char * name, int idx)
{
    // NOTE: no bounds checking/safe string function, etc

    for (int i = 0; i < FILES_count; i++)
    {
        if (strcmp(FILES_names[i], name) == 0)
        {
            int base_offset = FILES_offsets[i];
            return (FILE_ *)files + base_offset + idx;
        }
    }

    return NULL;
}

例如，这将获得指向files.winds[4]：

的指针

FILE_ * item = get_entry_by_name_and_index(&files, "winds", 4);
assert((void*)item == (void*)&files.winds[4]);

如何在C中动态访问struct的成员？

4 个答案: