3

我已经用 C(不是 C++)实现了一个链表,它存储指向数据的指针。我想对其函数有多个声明(以提供类型安全),但让它们中的每一个都链接到相同的定义(因为指向不同数据类型的指针之间没有实际区别,所以使用相同的代码可以减少空间)。

有没有人对如何实现这一点(或任何更好的方法)有任何想法?便携式解决方案显然是最好的,但我真的只需要在 GCC 中工作的东西。

4

3 回答 3

1

我相信您可以使用函数原型的 typedef 并将通用解决方案(在void*s 中处理)转换为特定原型来实现这一点。这对于编译应该是安全的,因为所有指针的大小都相同。

考虑这个例子:

do_something.h

typedef void (*do_something_with_int_t)(int *i);
extern do_something_with_int_t do_something_with_int;

typedef void (*do_something_with_string_t)(char *s);
extern do_something_with_string_t do_something_with_string;

do_something.c

#include "do_something.h"

void do_something_generic(void* p) {
    // Do something generic with p
}


do_something_with_int_t do_something_with_int =
    (do_something_with_int_t)do_something_generic;

do_something_with_string_t do_something_with_string =
    (do_something_with_string_t)do_something_generic;

只要do_something_generic真正与数据类型无关(即指向什么无所谓p),那么就可以了。

于 2013-05-23T02:21:34.700 回答
0

如果它是 C(不是 C++),那么下面的就可以了。您可以根据自己的需要调整概念。

tt.h

typedef struct {
    int ii;
} Type_1;

typedef struct {
    int ii;
} Type_2;

int foo_1(Type_1* ptr) __attribute__((alias("foo")));
int foo_2(Type_2* ptr) __attribute__((alias("foo")));

tt.c

#include <stdio.h>

#include "tt.h"

int main() {
    Type_1 t_1;
    Type_2 t_2;
    foo_1(&t_1);
    foo_2(&t_2);
}   

int foo(void* arg) {
    printf("foo: %p\n", arg);
}
于 2013-05-23T02:18:49.200 回答
0
#include <stdio.h>
struct common_type {
    int type;
};

struct type1 {
    int type;
    int value;
};

struct type2 {
    int type;
    char* p;
};

int func(void *para) {
    switch (((struct common_type*)para)->type) {
        case 1:
            printf("type1,value:%d\n",((struct type1*)para)->value);
            break;
        case 2:
            printf("type2,content:%s\n",((struct type2*)para)->p);
            break;
    }
}

int main() {
    char *s = "word";
    struct type1 t1 = {1,1};
    struct type2 t2;
    t2.type = 2;
    t2.p = s;
    func((void*)&t1);   
    func((void*)&t2);
}
于 2013-05-23T01:52:47.727 回答