Question

我有两个不同大小的结构，我想有一个功能，我可以将它们传入。但是，我不知道如何定义函数的参数来接受2个不同的结构。

我的结构在

之下

struct {
    int a;             // 2 byte
    int b;             // 2 byte
    int c;             // 2 byte
    int d;             // 2 byte
}  person1;                // 8 bytes


struct {
    int a;            // 2 byte
    DeviceAddress b;  // 8 bytes
    int c             // 2 bytes
    float d;      // 4 bytes
}  person2;               // 16 bytes

function print_struct(struct& ?????)
{
     actions here....
}


print_struct(person1);
print_struct(person2);

Answer 1

不幸的是，C中不相关结构的唯一选择是将指针传递给非类型化的结构（即void*），并传递“侧面”类型，如下所示：

struct person1_t {
    int a;             // 2 byte
    int b;             // 2 byte
    int c;             // 2 byte
    int d;             // 2 byte
}  person1;

struct person2_t {
    int a;            // 2 byte
    DeviceAddress b;  // 8 bytes
    int c             // 2 bytes
    float d;      // 4 bytes
}  person2;

void print_struct(void* ptr, int structKind) {
    switch (structKind) {
        case 1:
            struct person1 *p1 = (struct person1_t*)ptr;
            // Print p1->a, p1->b, and so on
            break;
        case 2:
            struct person2 *p2 = (struct person2_t*)ptr;
            // Print p2->a, p2->b, and so on
            break;
    }
}

print_struct(&person1, 1);
print_struct(&person2, 2);

但是，这种方法非常容易出错，因为编译器无法为您进行类型检查。

Answer 2

这不太可能。您可以创建一个包含两个结构的联合加上某种标识符。然后，您传入union并使用标识符来确定其中包含哪个结构。

typedef struct sp1 {
    int a;             // 2 byte
    int b;             // 2 byte
    int c;             // 2 byte
    int d;             // 2 byte
}  person1_t;          // 8 bytes


typedef struct sp2 {
    int a;            // 2 byte
    DeviceAddress b;  // 8 bytes
    int c             // 2 bytes
    float d;          // 4 bytes
}  person2_t;         // 16 bytes

typedef union {
    person1_t person1;
    person2_t person2;
} people;

function print_struct(people *p, int id) // e.g. id == 1, struct is person1
{
    switch (id)
    {
         case 1: // Do person 1 things
         break;

         case 2: // Do person 2 things
         break;

         default: // Error
         break;
    }
}

Answer 3

正如dasblinkenlight所说，如果你想能够将两个不同的结构传递给函数，使用void *传递通用指针将是可行的方法，但这样做并不是类型安全的很容易导致容易出错的代码。

你想通过两个独立的结构来实现什么功能？您可以考虑将信息组合到单个结构中，并使用打印函数打印出所有非零值吗？

原谅可能不是最优的c代码，我远非专家，这只是为了说明这一点：）

typedef struct datastruct {
    int a;
    int b;
    float c;
} datastruct;

void printData(datastruct *d){

    printf("Data:\n")
    printf((d->a) ? "a=%d", a : "");
    printf((d->b) ? "b=%d", b : "");
    printf((d->c) ? "c=%.2f", c : "");
    printf("\n");
}

int main(void) {

    datastruct data = {0};
    /* now set values as needed */

    printData(&data);

    return 0;
}

Answer 4

typedef struct p1 {
    int a;             // 2 byte
    int b;             // 2 byte
    int c;             // 2 byte
    int d;             // 2 byte
} person1;                // 8 bytes


typedef struct p2{
    int a;            // 2 byte
    DeviceAddress b;  // 8 bytes
    int c             // 2 bytes
    float d;      // 4 bytes
} person2;               // 16 bytes

typedef enum ptypes {
    PERSON1,
    PERSON2
} person_type;

typedef union p1_or_p2 {
    person1 p1;
    person2 p2;
} person1_or_person2;

typedef struct p {
    person1_or_person2 person;
    person_type type;
} person;

// Creating a person struct variable:
person p;
person1 p1;
p1.a = 5;
p1.b = 2;
p.type = PERSON1;
p.person = (person1_or_person2) p1;

void print_struct(person p) {
     switch (p.type) {
        case PERSON1:
            // actions for person1 here....
              // you can access person1 like this:
                 p.person.p1;
        break;
        case PERSON2:
            // actions for person2 here....
              // you can access person2 like this:
                 p.person.p2;
        break;
     }
}

将两个不同的结构传递到相同的函数中

4 个答案: