c - 我应该如何返回 C 库中二元运算函数的结果？

Question

我正在开发一个 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 个参数；两个用于操作数，一个用于存储结果，但同样不是很直观。

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

Answer 1

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

• Allocating to the heap is significantly slower than plain stack operations.
• Every allocation will also need to be free()d, meaning every instance will require at least 2 function invocations, where as just using a stack based design would require none.
• Since memory has to be manually managed it leaves much more room for memory leaks.
• Memory allocations can fail! A stack based system would alleviate this.
• Using pointers would require dereferencing. This is slower than direct access, and requires more (perhaps, sloppy) sytax.

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

简而言之，简单地依靠堆栈来处理所有事情是最好的，不仅是为了性能，也是为了维护和干净的代码。唯一要记住的是堆栈是有限的，而且它也很容易变得疯狂。将堆栈用于短期数据(在本例中为二元运算结果)，将堆用于较重的长期数据。

希望对您有所帮助! :)

_{注意:此答案中的大部分信息均来自@ Justin .}