C 处理函数中结构数组的成员

假设我有

struct my_type_t {
    int x;
    int y;
    int z;
};

struct my_array_t {
    struct my_type_t test;
    int otherstuff;
};

int main(void) {
    struct my_array_t arrayofstructs[200];
    somefunction(arrayofstructs);

    return 0;
}

void somefunction(struct my_array_t *arrayofstructs, somevariable) {
    for (int i; i < 200; i++) {
        //Do stuff to 
        arrayofstructs->test[i].somevariable;
    }
}

struct my\u type\t{
int x；
int-y；
intz；
};
结构我的数组{
结构型式试验；
其他东西；
};
内部主（空）{
结构my_array_t arrayofstructs[200]；
somefunction（arrayofstructs）；
返回0；
}
void somefunction（结构my_数组*arrayofstructs，somevariable）{
用于（int i；i<200；i++）{
//设法
arrayofstructs->test[i].somevariable；
}
}

如何传入某个变量来告诉函数处理结构数组的该成员（x、y或z）

谢谢

enum字段类型
enum FieldTypes
{
   FIELD_X,
   FIELD_Y,
   FIELD_Z
};

int main(void)
{
    struct my_array_t arrayofstructs[200];
    somefunction(arrayofstructs,FIELD_X);

    return 0;
}

void somefunction(struct my_array_t *arrayofstructs, FieldTypes somevariable) 
{
    switch( somevariable )
    {
        case FIELD_X:

           for (int i; i < 200; i++) 
           {
               //Do stuff to arrayofstructs->test[i].x; 
           }
           break;

        case FIELD_Y:

           for (int i; i < 200; i++) 
           {
               //Do stuff to arrayofstructs->test[i].y; 
           }
           break;

        case FIELD_Z:

           for (int i; i < 200; i++) 
           {
               //Do stuff to arrayofstructs->test[i].z;
           }
           break;
    }
}

{
场_X，
实地调查，
场区
};
内部主（空）
{
结构my_array_t arrayofstructs[200]；
somefunction（arrayofstructs，FIELD_X）；
返回0；
}
void somefunction（struct my_array_t*arrayofstructs，FieldTypes somevariable）
{
开关（变量）
{
案例字段_X：
用于（int i；i<200；i++）
{
//对arrayofstructs->test[i].x执行任务；
}
打破
案例字段Y：
用于（int i；i<200；i++）
{
//做一些事情来排列结构->测试[i].y；
}
打破
案例字段_Z：
用于（int i；i<200；i++）
{
//对arrayofstructs->test[i].z做一些事情；
}
打破
}
}

如果目的是始终执行相同的操作，但只是基于传递的值在结构的不同元素上执行，那么您可以这样做

void somefunction(struct my_array_t *arrayofstructs, FieldTypes somevariable) 
{
    for (int i; i < 200; i++) 
    {
        int* workingValue;

        switch( somevariable )
        {
            case FIELD_X: workingValue = &arrayofstructs->test[i].x;  break;
            case FIELD_Y: workingValue = &arrayofstructs->test[i].y;  break;
            case FIELD_Z: workingValue = &arrayofstructs->test[i].z;  break;
        }

        // do stuff to *workingValue -- no redundant code here
    }
}

void somefunction（struct my_array_t*arrayofstructs，FieldTypes somevariable）
{
用于（int i；i<200；i++）
{
int*工作值；
开关（变量）
{
案例字段X:workingValue=&arrayofstructs->test[i].X；break；
案例字段Y:workingValue=&arrayofstructs->test[i].Y；break；
案例字段_Z:workingValue=&arrayofstructs->test[i].Z；break；
}
//对*workingValue执行操作--此处没有冗余代码
}
}

事实一：你应该通过，

数组结构

，而不是

&数组结构

解决问题的方法如下：

void someFn(data_type *var , int somevar) {
  ...
  ...
  ...
  switch(somevar) {

  case <some_value>:
  some_task;
  break;

  ...
  ...
  ...
  } //End switch

  }

void somefunction(struct my_array_t *arrayofstructs, char whichVar) {
    for (int i; i < 200; i++) {
        //Do stuff to 
        switch(whichVar){
            case 'x': arrayofstructs->test[i].x; break;
            case 'y': arrayofstructs->test[i].y; break;
            case 'z': arrayofstructs->test[i].z; break;
        }
    }
}

#define GET_STRUCT_OFFSET(st, m) ((size_t) ( (char *)&((st *)(0))->m - (char *)0 ))

---

这有助于清除冗余：）

只需使用一些不同的值即可让函数区分它们。您可以使用

enum

、一些

#define

s或

char

，如下所示：

void someFn(data_type *var , int somevar) {
  ...
  ...
  ...
  switch(somevar) {

  case <some_value>:
  some_task;
  break;

  ...
  ...
  ...
  } //End switch

  }

void somefunction(struct my_array_t *arrayofstructs, char whichVar) {
    for (int i; i < 200; i++) {
        //Do stuff to 
        switch(whichVar){
            case 'x': arrayofstructs->test[i].x; break;
            case 'y': arrayofstructs->test[i].y; break;
            case 'z': arrayofstructs->test[i].z; break;
        }
    }
}

#define GET_STRUCT_OFFSET(st, m) ((size_t) ( (char *)&((st *)(0))->m - (char *)0 ))

void somefunction（struct my_array_t*arrayofstructs，char whichVar）{
用于（int i；i<200；i++）{
//设法
开关（whichVar）{
案例“x”：阵列结构->测试[i]。x；中断；
案例“y”：阵列结构->测试[i]。y；中断；
案例“z”：arrayofstructs->test[i].z；break；
}
}
}

请注意，使用

#define

s或

enum

s通常被认为是更好的做法，因为您可以为值指定有意义的名称。这里的

char

用法只是一个例子

---

另请参见

使用switch case的其他答案可能更干净，但如果一些黑客行为还可以，您可以使用以下内容：

void someFn(data_type *var , int somevar) {
  ...
  ...
  ...
  switch(somevar) {

  case <some_value>:
  some_task;
  break;

  ...
  ...
  ...
  } //End switch

  }

void somefunction(struct my_array_t *arrayofstructs, char whichVar) {
    for (int i; i < 200; i++) {
        //Do stuff to 
        switch(whichVar){
            case 'x': arrayofstructs->test[i].x; break;
            case 'y': arrayofstructs->test[i].y; break;
            case 'z': arrayofstructs->test[i].z; break;
        }
    }
}

#define GET_STRUCT_OFFSET(st, m) ((size_t) ( (char *)&((st *)(0))->m - (char *)0 ))

（见附件）

要访问结构的成员，请执行以下操作：

int main(void) {
    struct my_array_t arrayofstructs[200];
    somefunction(arrayofstructs, GET_STRUCT_OFFSET(struct my_type_t, x));

   return 0;
}

void somefunction(struct my_array_t *arrayofstructs, int offset)
{
    for (int i; i < 200; i++) {
        //Do stuff to 
        (((void*)&arrayofstructs[i].test) + offset);
    }
}

int main（无效）{
结构my_array_t arrayofstructs[200]；
somefunction（arrayofstructs，GET_STRUCT_OFFSET（STRUCT my_type_t，x））；
返回0；
}
void somefunction（结构我的数组*数组结构，整数偏移）
{
用于（int i；i<200；i++）{
//设法
（（（void*）和arrayofstructs[i].测试）+偏移量）；
}
}

同样，这是一个非常简单的测试：

编辑：

---

在

中有一个

offset of

宏，该宏使用以下代码完成相同的操作：

正确，arrayofstructs是arrayofstructs[]的地址；我希望有一种不使用switch case的更简单的方法。@user2272403:arrayofstructs是arrayofstructs[0]：）是的，是0。有些任务相当大，所以我试图消除冗余代码。很抱歉，我们无法做到这一点，我认为冗余代码在您的案例中无法消除。。。我曾想过使用地址偏移量，但这看起来比我尝试实现它时更干净。我会查出来的。不是你要的，但应该是

arrayofstructs[I]。test.somevariable

。我希望消除冗余代码，但我确实喜欢枚举字段类型和大小写切换的想法。我考虑过使用地址偏移，但这段代码需要在不同结构对齐的机器之间进行移植，我认为使用这项技术会造成问题。@user2272403请参阅编辑我刚刚意识到有一个标准版本。我也喜欢这一个。不过，每一次循环迭代都需要额外添加一个宏，但每件事情都是有代价的。公平地说，宏需要额外添加一点，就像切换情况一样。尽管我怀疑这两种方法与“做事”相比都会成为瓶颈。