5

我有 2 个不同大小的结构，我想有一个可以将它们传递到的函数。但是，我不知道如何定义函数的参数以接受 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);
4

4 回答 4

6

不幸的是，C 中不相关结构的唯一选择是将指针传递给无类型的结构（即 as 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);

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

于 2013-01-14T18:22:51.843 回答
3

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

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;
    }
}
于 2013-01-14T18:19:11.180 回答
0

正如 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;
}
于 2013-03-11T14:02:43.523 回答
-2 
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;
     }
}
于 2013-01-14T18:20:07.260 回答