3

假设我有

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;
    }
}

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

谢谢！

4

4 回答 4

1

事实一： 你应该通过，arrayofstructs而不是&arraystructs。

处理您的问题的方法是这样的：

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

  case <some_value>:
  some_task;
  break;

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

  }

即，您传递与每个成员相关的标识符，并使用选择性结构根据输入的标识符执行某些任务。

举个简单的例子，somevar可以是整数，你必须知道整数中的值对应什么。

编辑

或者您可以执行以下操作

struct mystr{
  int mem[3];
}

void someFn(struct mystr a, int somevar){ 

  //now access those with a[i].mem[somevar]
}

这有助于清除冗余:)

于 2013-04-15T18:19:59.363 回答
1

使用 switch case 的其他答案可能更干净，但如果一些 hackiness 是好的，你可以使用这样的东西：

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

（请参阅为什么这个 offsetof() 的实现有效？）

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

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);
    }
}

再次非常hacky，但它确实有效，这是一个简单的测试：http: //ideone.com/zwvTY1

编辑：

有<stddef.h>一个offsetof宏使用它来完成相同的事情代码：http: //ideone.com/9aDo2c

于 2013-04-15T18:45:23.983 回答
0 
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;
    }
}

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

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
    }
}
于 2013-04-15T18:16:55.007 回答
0

只需使用一些不同的值来让您的函数区分它们。你可以使用 an enum， some #defines 或者 a char，像这样：

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;
        }
    }
}

请注意，使用#defines 或enums 通常被认为是更好的做法，因为您可以为您的值赋予有意义的名称。这里的char用法只是一个例子。

另请参阅什么是幻数，为什么它不好？

于 2013-04-15T18:21:44.080 回答