通用性与类型安全？在 C 中使用 void*

Question

来自 OO（C#、Java、Scala），我非常重视代码重用和类型安全的原则。上述语言中的类型参数可以完成这项工作并启用通用数据结构，这些数据结构既是类型安全的，又不会“浪费”代码。

当我陷入 C 语言时，我意识到我必须做出妥协，并且我希望它是正确的。要么我的数据结构在每个节点/元素中都有一个 void * 并且我失去了类型安全性，要么我必须为我想要使用它们的每种类型重新编写我的结构和代码。

代码的复杂性是一个明显的因素：遍历数组或链表很简单，向结构添加 *next 也不需要额外的工作；在这些情况下，不尝试重用结构和代码是有意义的。但对于更复杂的结构，答案并不那么明显。

还有模块化和可测试性：将类型及其操作与使用该结构的代码分开可以使测试更容易。反之亦然：在结构上测试某些代码的迭代，同时尝试做其他事情会变得混乱。

那么你的建议是什么？ void * 和重用或类型安全和重复的代码？有什么一般原则吗？当 OO 不适合时，我是否试图强制它采用程序化？

编辑：请不要推荐C++，我的问题是关于C的！

Answer 1

我会说使用 void * 这样你就可以重复使用代码。重新实现例如链接列表比确保正确获取/设置列表中的数据要做更多的工作。

尽可能多地从 glib 获取提示，我发现它们的数据结构非常好且简单使用起来，并且由于类型安全性的丧失而遇到了一些麻烦。

Answer 2

我认为你必须在两者之间取得平衡，就像你建议的那样。如果代码只有几行而且很琐碎，我会复制它，但如果它更复杂，我会考虑使用 void* 以避免在多个地方进行任何潜在的错误修复和维护，并且以减少代码大小。

如果您查看 C 运行时库，就会发现有几个与 void* 一起使用的“通用”函数，一个常见的示例是使用 qsort 进行排序。为您想要排序的每种类型复制此代码将是疯狂的。

Answer 3

使用 void 指针没有任何问题。当将它们分配给指针类型的变量时，您甚至不必对它们进行强制转换，因为转换是在内部完成的。可能值得一看：http://www.cpax.org .uk/prg/writings/casting.php

Answer 4

这个问题的答案与在 C++ 中获取链接列表的高效模板相同。

a) 创建使用 void* 或某些抽象类型的算法的抽象版本

b) 创建一个轻量级公共接口来调用抽象类型算法并在它们之间进行种姓。

例如。

typedef struct simple_list
  {
  struct simple_list* next;
  } SimpleList;

void add_to_list( SimpleList* listTop, SimpleList* element );
SimpleList* get_from_top( SimpleList* listTop );
// the rest

#define ListType(x) \
    void add_ ## x ( x* l, x* e ) \
        { add_to_list( (SimpleList*)l, (SimpleList*)x ); } \
    void get_ ## x ( x* l, x* e ) \
        { return (x*) get_from_to( (SimpleList*)l ); } \
   /* the rest */

typedef struct my_struct
  {
  struct my_struct* next;
  /* rest of my stuff */
  } MyStruct;

ListType(MyStruct)

MyStruct a;
MyStruct b;

add_MyStruct( &a, &b );
MyStruct* c = get_MyStruct(&a);

等等等等

Answer 5

我们在这里在C中大量使用OO，但只是为了封装和抽象，没有多态等等。

这意味着我们有特定的类型，例如 FooBar(Foo a, ...) 但是，对于我们的集合“类”，我们使用 void *。只需在可以使用多种类型的地方使用 void * 即可，但是，通过这样做，可以确保您不需要参数是特定类型。对于集合来说，拥有 void * 是可以的，因为集合不关心类型。但是，如果您的函数可以接受类型 a 和类型 b，但不能接受其他类型，请制作两种变体，一种用于 a，一种用于 b。

要点是仅当您不关心类型时才使用 void *。

现在，如果您有 50 个具有相同基本结构的类型（比方说，int a; int b; 作为所有类型的第一个成员），并且想要一个函数对这些类型进行操作，只需将公共第一个成员本身设置为一个类型即可，然后让函数接受这个，并传递 object->ab 或 (AB*)object 如果你的类型是不透明的，如果 ab 是结构中的第一个字段，则两者都可以工作。

Answer 6

您可以使用宏，它们适用于任何类型，并且编译器将静态检查扩展代码。缺点是代码密度（二进制）会变差并且更难以调试。

我问了这个关于泛型函数的问题一些不久前，答案可以帮助你。

Answer 7

您可以有效地向 C 数据结构添加类型信息、继承和多态性，这就是 C++ 所做的。 (http://www.embedded.com/97/fe29712.htm)

Answer 8

绝对通用的void*，绝不重复代码！

考虑到许多 C 程序员和许多主要 C 项目都考虑过这种困境。我遇到过的所有严肃的 C 项目，无论是开源的还是商业的，都选择了通用的 void*。当仔细使用并封装成一个好的 API 时，它对库的用户来说几乎不会造成负担。而且，void*是C语言惯用的，在K&R2中直接推荐。这是人们期望的代码编写方式，其他任何事情都会令人惊讶且难以接受。

Answer 9

您可以使用 C 构建一个（某种）OO 框架，但是您会错过很多好处……比如编译器可以理解的 OO 类型系统。如果你坚持使用类C语言进行OO，C++是更好的选择。它比普通的 C 更复杂，但至少你得到了面向对象的适当的语言支持。

编辑：好的...如果您坚持认为我们不推荐 C++，我建议您不要在 C 中进行 OO。高兴吗？就您的面向对象习惯而言，您可能应该从“对象”的角度来思考，但将继承和多态性排除在您的实现策略之外。应谨慎使用通用性（使用函数指针）。

编辑2：实际上，我认为在通用C列表中使用void *是合理的。它只是试图使用宏、函数指针、调度和我认为是个坏主意的那种废话来构建一个模拟的 OO 框架。

Answer 10

在 Java 中，java.util 包中的所有集合实际上都持有等价的 void* 指针（Object）。

是的，泛型（在 1.5 中引入）添加了语法糖并防止您编写不安全的赋值，但存储类型仍然是 Object。

因此，我认为当您使用 void* 作为通用框架类型时，并没有犯下面向对象的罪行。

如果您在代码中经常这样做，我还会添加特定于类型的内联或宏包装器，以便从通用结构中分配/检索数据。

PS 您不应该做的一件事是使用 void** 返回分配/重新分配的泛型类型。如果您检查 malloc/realloc 的签名，您会发现您可以实现正确的内存分配，而无需可怕的 void** 指针。我之所以这么说，是因为我在一些开源项目中看到过这一点，我不想在这里透露名称。

Answer 11

可以通过一些工作来包装通用容器，以便可以在类型安全版本中实例化它。这是一个示例，完整的标头链接如下：

/* genericimplementation */

struct deque *deque_next(struct deque *dq);

void *deque_value(const struct deque *dq);

/* Prepend a node carrying `value` to the deque `dq` which may
 * be NULL, in which case a new deque is created.
 * O(1)
 */
void deque_prepend(struct deque **dq, void *value); 

来自可用于实例化 deque 的特定包装类型的标头 deque.h

#include "deque.h"

#ifndef DEQUE_TAG
#error "Must define DEQUE_TAG to use this header file"
#ifndef DEQUE_VALUE_TYPE
#error "Must define DEQUE_VALUE_TYPE to use this header file"
#endif
#else

#define DEQUE_GEN_PASTE_(x,y) x ## y
#define DEQUE_GEN_PASTE(x,y) DEQUE_GEN_PASTE_(x,y)
#define DQTAG(suffix) DEQUE_GEN_PASTE(DEQUE_TAG,suffix)

#define DQVALUE DEQUE_VALUE_TYPE

#define DQREF DQTAG(_ref_t)

typedef struct {
    deque_t *dq;
} DQREF;

static inline DQREF DQTAG(_next) (DQREF ref) {
    return (DQREF){deque_next(ref.dq)};
}

static inline DQVALUE DQTAG(_value) (DQREF ref) {
    return deque_value(ref.dq);
}

static inline void DQTAG(_prepend) (DQREF *ref, DQVALUE val) {
    deque_prepend(&ref->dq, val);
}

• : http://ideone.com/eDNBN
• deque_gen.h：http://ideone.com /IkJRq