1

我正在开发一个 C 库，其中一部分处理一些数学类型并对其进行操作。每种类型都有一个工厂构造函数/析构函数，可以动态分配和释放它们。例如：

/* Example type, but illustrates situation very well. */
typdef struct {
    float x;
    float y;
    float z;
} Vector3D;

/* Constructor */
Vector* Vector3D_new(float x, float y, float z) {
     Vector3D* vector = (Vector3D*) malloc(sizeof(Vector3D));
     /* Initialization code here...*/

     return vector;
}

/* Destructor */
void Vector3D_destroy(Vector3D* vector) {
    free(vector);
}

很好很简单，也减轻了用户正确初始化的负担。

现在我主要关心的是如何处理对这些类型进行操作的函数（特别是如何返回结果值。）几乎每个二进制操作都会导致相同类型的新实例，因此，我需要考虑如何给出这个回给用户。我可以按值返回东西，但最好传递指针，因为它更快，与构造/析构方法兼容，并且不会给用户留下太多负担。

目前我通过让函数动态分配结果来实现它，然后返回一个指向它的指针：

/* Perform an operation, and dynamically return resultant vector */
Vector3D* addVectors(Vector3D* a, Vector3D* b) {
    Vector3D* c = Vector3D_new(
        a->x + b->x,
        a->y + b->y,
        a->z + b->z);

    return c; 
}

通过将值直接返回给用户，它的优点是可以被链接起来（例如直接作为参数传递给另一个函数），例如：

/* Given three Vector3D*s : a, b, & c */
float dot = dotProduct(crossProduct(a, addVectors(b, c));

但是考虑到当前的方法，这将导致内存泄漏，因为 ' 的结果addVectors()将直接传递给crossProduct()，而用户将没有机会获得free()它（与crossProduct()' 的结果传递给的结果相同dotProduct()）。为了使这项工作，一个人必须制作一个指针来保存值，使用它，然后free()通过所述指针。

Vector3D* d = addVectors(b, c);
Vector3D* e = crossProduct(a, d);
float dot = dotProduct(e);

Vector3D_destroy(d);
Vector3d_destroy(e);

这可行，但不太直观，并且失去了我如此渴望的链接效果。

另一种可能性是让操作函数接受 3 个参数；两个用于操作数，一个用于存储结果，但也不是很直观。

那么我的问题是： 在二进制操作中使用动态内存有哪些优雅且高效的方法？作为奖励，在现实世界的图书馆中使用的解决方案会非常酷。有任何想法吗？:)

4

3 回答 3

2

除了您提到的内存泄漏之外，您当前的系统还有一些其他问题：

  • 分配到堆比普通堆栈操作慢得多。
  • 每个分配也需要为free()d，这意味着每个实例都需要至少2 次函数调用，而仅使用基于堆栈的设计则不需要。
  • 由于必须手动管理内存，因此为内存泄漏留下了更多空间。
  • 内存分配可能会失败！基于堆栈的系统将缓解这种情况。
  • 使用指针需要取消引用。这比直接访问要慢，并且需要更多（也许是草率的）语法。

除此之外，许多编译器缓存用于程序堆栈的内存，并且可以提供对堆的显着改进（几乎从不缓存（如果可能的话！））

简而言之，一切都依赖堆栈是最好的，不仅是为了性能，还有维护和干净的代码。唯一要记住的是堆栈是有限的，而且它也很容易发疯。将堆栈用于短期数据（在这种情况下为二元运算结果），将堆用于较重的长期数据。

我希望这有帮助！:)

注意：此答案中的大部分信息都归功于@ Justin。

于 2012-06-15T05:01:33.863 回答
1

我会做的很简单

Vector3D addVectors(Vector3D a, Vector3D b) {
    Vector3D c;
    c.x = a.x + b.x;
    c.y = a.y + b.y;
    c.z = a.z + b.z;
    return c;
}

如果调用者在堆上确实需要它，他可以自己复制它。

于 2012-06-11T19:25:27.810 回答
1

在运算符内部进行分配并不像看起来那么方便。
这主要是因为您没有垃圾收集，还因为您必须担心分配失败。

考虑这段代码：

Vector3D *v1,*v2,*v3;
Vector3d v4 = addVectors(v1,multiplyVectors(v2,v3));

看起来很好。
但是从返回的向量会发生什么multiplyVectors？内存泄漏。
如果分配失败会发生什么？其他一些功能崩溃。

我会就地添加：
void addVectors(Vector3D *target, const Vector3D *src);
这相当于target += src;.

于 2012-06-11T18:51:08.527 回答