使用宏在 C 中实现泛型向量。这是个好主意吗？

Question

我是一名同时了解 C 和 C++ 的程序员。我在自己的项目中使用过这两种语言，但我不知道我更喜欢哪一种。

当我用 C 编程时，我最怀念 C++ 的功能是来自 STL（标准模板库）的 std::vector

我还没有弄清楚我应该如何在 C 中表示不断增长的数组。到目前为止，我在项目中的所有地方都复制了我的内存分配代码。我不喜欢代码重复，我知道这是不好的做法，所以这对我来说似乎不是一个很好的解决方案。

我前段时间考虑过这个问题，并想出了使用预处理器宏实现泛型向量的想法。

这是实现的样子：

#ifndef VECTOR_H_
#define VECTOR_H_

#include <stdlib.h>
#include <stdio.h>

/* Declare a vector of type `TYPE`. */
#define VECTOR_OF(TYPE) struct { \
    TYPE *data; \
    size_t size; \
    size_t capacity; \
}

/* Initialize `VEC` with `N` capacity. */
#define VECTOR_INIT_CAPACITY(VEC, N) do { \
    (VEC).data = malloc((N) * sizeof(*(VEC).data)); \
    if (!(VEC).data) { \
        fputs("malloc failed!\n", stderr); \
        abort(); \
    } \
    (VEC).size = 0; \
    (VEC).capacity = (N); \
} while (0)

/* Initialize `VEC` with zero elements. */
#define VECTOR_INIT(VEC) VECTOR_INIT_CAPACITY(VEC, 1)

/* Get the amount of elements in `VEC`. */
#define VECTOR_SIZE(VEC) (VEC).size

/* Get the amount of elements that are allocated for `VEC`. */
#define VECTOR_CAPACITY(VEC) (VEC).capacity

/* Test if `VEC` is empty. */
#define VECTOR_EMPTY(VEC) ((VEC).size == 0)

/* Push `VAL` at the back of the vector. This function will reallocate the buffer if
   necessary. */
#define VECTOR_PUSH_BACK(VEC, VAL) do { \
    if ((VEC).size + 1 > (VEC).capacity) { \
        size_t n = (VEC).capacity * 2; \
        void *p = realloc((VEC).data, n * sizeof(*(VEC).data)); \
        if (!p) { \
            fputs("realloc failed!\n", stderr); \
            abort(); \
        } \
        (VEC).data = p; \
        (VEC).capacity = n; \
    } \
    (VEC).data[VECTOR_SIZE(VEC)] = (VAL); \
    (VEC).size += 1; \
} while (0)

/* Get the value of `VEC` at `INDEX`. */
#define VECTOR_AT(VEC, INDEX) (VEC).data[INDEX]

/* Get the value at the front of `VEC`. */
#define VECTOR_FRONT(VEC) (VEC).data[0]

/* Get the value at the back of `VEC`. */
#define VECTOR_BACK(VEC) (VEC).data[VECTOR_SIZE(VEC) - 1]

#define VECTOR_FREE(VEC) do { \
    (VEC).size = 0; \
    (VEC).capacity = 0; \
    free((VEC).data); \
} while(0)

#endif /* !defined VECTOR_H_ */

此代码位于名为 "vector.h" 的头文件中。

请注意，它确实缺少一些功能（例如 VECTOR_INSERT 和 VECTOR_ERASE），但我认为它足以展示我的概念。

向量的使用是这样的：

int main()
{
    VECTOR_OF(int) int_vec;
    VECTOR_OF(double) dbl_vec;
    int i;

    VECTOR_INIT(int_vec);
    VECTOR_INIT(dbl_vec);

    for (i = 0; i < 100000000; ++i) {
        VECTOR_PUSH_BACK(int_vec, i);
        VECTOR_PUSH_BACK(dbl_vec, i);
    }

    for (i = 0; i < 100; ++i) {
        printf("int_vec[%d] = %d\n", i, VECTOR_AT(int_vec, i));
        printf("dbl_vec[%d] = %f\n", i, VECTOR_AT(dbl_vec, i));
    }

    VECTOR_FREE(int_vec);
    VECTOR_FREE(dbl_vec);

    return 0;
}

它使用与std::vector 相同的分配规则（大小从1 开始，然后每次需要时加倍）。

令我惊讶的是，我发现这段代码的运行速度是使用 std::vector 编写的相同代码的两倍以上 并且 生成的可执行文件更小！ （使用 GCC 和 G++ 编译，在两种情况下都使用 -O3）。

我的问题是：

• 这种方法是否存在严重缺陷？
• 您是否建议在严肃的项目中使用它？
• 如果不是，那么我希望您解释一下为什么，并告诉我有什么更好的选择。

Answer 1

令我惊讶的是，我发现这段代码的运行速度是使用 std::vector 编写的相同代码的两倍多，并且生成的可执行文件更小！ （在两种情况下都使用 -O3 使用 GCC 和 G++ 编译）。

您的 C 版本比 C++ 版本更快/更小的三个原因：

1. g++ 使用的标准 C++ 库中 new 的实现不是最理想的。如果您将void* operator new (size_t size) 实现为对malloc() 的调用，您将获得比内置版本更好的性能。

2. 如果realloc() 必须使用新的内存块，它会以memmove() 的方式移动旧数据，即。 e.它忽略了数据的逻辑结构，只是移动了位。该操作可以很容易地加速到内存总线成为瓶颈的程度。另一方面，std::vector<> 必须注意可能正确调用构造函数/析构函数，它不能只调用memmove()。在int 和double 的情况下，归结为一次将数据移动一个int/double，循环位于为std::vector<> 生成的代码中。这并不算太糟糕，但它比使用良好的memmove() 实现的 SSE 指令更糟糕。

3. realloc() 函数是标准 C 库的一部分，它动态链接到您的可执行文件。而std::vector<>生成的内存管理代码恰恰是：生成的。因此，它必须是可执行文件的一部分。

这种方法有什么严重的缺陷吗？

这是一个口味问题，但我认为，这种方法很臭：您的宏定义与它们的用途相去甚远，而且它们的行为并不都像简单的常量或内联函数。事实上，它们的行为可疑地类似于编程语言的元素（即模板），这对预处理器宏来说不是一件好事。尝试使用预处理器修改语言通常是个坏主意。

您的宏实现也存在严重问题：VECTOR_INIT_CAPACITY(VEC, N) 宏对其 VEC 参数求值四次，N 参数求值两次。现在想想如果你调用VECTOR_INIT_CAPACITY(foo, baz++)会发生什么：新向量的capacity字段中存储的大小将大于为其分配的内存大小。带有malloc() 调用的行将增加baz 变量，并且该新值将在baz 第二次增加之前存储在capacity 成员中。您应该以一种对它们的参数只求值一次的方式编写所有宏。

您会建议在严肃的项目中使用它吗？

我想，我不会打扰。 realloc() 代码很简单，一些复制不会造成太大伤害。但同样，您的里程可能会有所不同。

如果不是，那么我希望您解释原因并告诉我更好的选择。

正如我之前所说，我不会费心尝试以std::vector<> 的风格编写一个通用容器类，既不是通过（ab）使用预处理器，也不是通过（ab）使用void*。

但我会仔细研究我编写的系统上的内存处理：对于许多内核，您极不可能从malloc()/@987654351 中获得NULL 的返回值@ 称呼。他们过度投入记忆，做出他们无法确定能够兑现的承诺。当他们意识到他们无法兑现他们的承诺时，他们开始通过 OOM-killer 进行射击。在这样的系统上（Linux 就是其中之一），您的错误处理毫无意义。它永远不会被执行。因此，您可以避免添加它并将其复制到需要动态增长数组的所有位置的痛苦。

我在 C 中的内存重新分配代码通常如下所示：

if(size == capacity) {
    array = realloc(array, (capacity *= 2) * sizeof(*array));
}
array[size++] = ...;

如果没有无功能的错误处理代码，它是如此之短，以至于可以安全地复制它需要的次数。

Answer 2

这种方法有什么严重的缺陷吗？

您正在以一种与 C 的类型系统交互不佳的方式重新设计模板。例如，您的 VECTOR 类型是匿名的，所以我不能编写一个将 VECTOR_OF(int) 作为参数的函数。

即使您确实以某种方式命名您的类型，我也无法编写一个通用的函数---将VECTOR_OF(T) 用于任意T 并对其进行处理的东西.

这些可能不是严重的错误，但我在 C 中看到的每一种使用泛型使用宏的方法都有一百个这样的小缺点。这一切都是因为该语言根本不尝试支持泛型编程.

您会建议在严肃的项目中使用它吗？

当然；您可以使用这样的容器类型开发一个严肃的项目，它们甚至不一定会出现在您的面前。您可能需要通过 void * 来传递这些东西，这会导致一些容易出错的转换。

Answer 3

我的问题是： 这种方法有什么严重的缺陷吗？

是的，您正在尝试重塑 the wheel。

您会建议在严肃的项目中使用它吗？

不，特别是因为您的加速通常表明您可能会错过一些安全检查。

如果不是，那么我希望您解释原因并告诉我更好的选择。

VPool 从上面，或其他类似的东西。如果您搜索“C 可增长缓冲区”，您会在 stackoverflow 和谷歌上找到一些提示