C 中的对象方法：内存泄漏

Question

我对如何在 C 中正确实现对象有疑问。

我从方法返回对象是否比从不返回对象并像这样在参数列表中通过引用来执行它更容易发生内存泄漏？

extern void quaternion_get_product(Quaternion * this, Quaternion * q, Quaternion * result);

这样malloc()的调用只在构造函数中进行，比较容易控制。

我是 C 中这种封装的新手，所以我不确定这是否能解决我的问题。我只是希望我的代码具有可扩展性，并且我发现如果我继续这样做，内存泄漏将无处不在，而且很难调试。通常是如何处理的？我的代码是否在正确的轨道上？

我的问题是，如果我有这个：

Quaternion p = *quaternion_create(1, 0, 0, 0);
Quaternion q = *quaternion_create(1, 0, 1, 0);
Quaternion r = *quaternion_create(1, 1, 1, 0);
Quaternion s = *quaternion_create(1, 1, 1, 1);

p = *quaterion_get_product(&p, &q); // Memory leak, old p memory block is not being pointed by anyone

Quaternion t = *quaternion_get_product(&q, quaternion_get_product(&s, &r)); 

嵌套函数调用时存在内存泄漏，任何现有指针均未指向中间内存块，无法调用 quaternion_destroy

头文件：

#ifndef __QUATERNIONS_H_
#define __QUATERNIONS_H_

#include <stdlib.h>

typedef struct Quaternion Quaternion;

struct Quaternion {
    float w;
    float x;
    float y;
    float z;
};

extern Quaternion *quaternion_create(float nw, float nx, float ny, float nz);
extern void quaternion_destroy(Quaternion *q);
extern Quaternion *quaternion_get_product(Quaternion *this, Quaternion *q);
extern Quaternion *quaternion_get_conjugate(Quaternion *this);
extern float quaternion_get_magnitude(Quaternion *this);
extern void quaternion_normalize(Quaternion *this);
extern Quaternion *quaternion_get_normalized(Quaternion *this);
#endif

实施文件：

#include "quaternion.h"
#include <math.h>

Quaternion *quaternion_create(float nw, float nx, float ny, float nz) {
    Quaternion *q = malloc(sizeof(Quaternion));

    q->w = nw;
    q->x = nx;
    q->y = ny;
    q->z = nz;
    return q;
}

void quaternion_destroy(Quaternion *q) {
    free(q);
}

Quaternion *quaternion_get_product(Quaternion *this, Quaternion *p) {
        Quaternion *return_q = quaternion_create(
            this->w * p->w - this->x * p->x - this->y * p->y - this->z * p->z,  // new w
            this->w * p->x + this->x * p->w + this->y * p->z - this->z * p->y,  // new x
            this->w * p->y - this->x * p->z + this->y * p->w + this->z * p->x,  // new y
            this->w * p->z + this->x * p->y - this->y * p->x + this->z * p->w
        );
        return return_q;
}

Quaternion *quaternion_get_conjugate(Quaternion *this)
{
        return quaternion_create(this->w, -this->x, -this->y, -this->z);
}

float quaternion_get_magnitude(Quaternion *this) {
        return sqrt(this->w * this->w + this->x * this->x + this->y * this->y + this->z * this->z);
}

void quaternion_normalize(Quaternion *this) {
        float m = quaternion_get_magnitude(this);
        this->w /= m;
        this->x /= m;
        this->y /= m;
        this->z /= m;
}

Quaternion *quaternion_get_normalized(Quaternion *this) {
        Quaternion *r = quaternion_create(this->w, this->x, this->y, this->z);
        quaternion_normalize(r);
        return r;
}

Answer 1

实际上，如果某些函数具有更新某些内容并返回新构造值的两者副作用，则情况会变得更糟。说吧，谁记得scanf返回值？

看看GNU Multi Precision Arithmetic Library，我建议以下是一种合理的解决方案（实际上，他们更进一步让内存分配让用户头痛，而不是图书馆）：

1. 只有构造函数才能创建新对象。我还建议所有构造函数的名称都遵循相同的模式。
2. 只有析构函数才能销毁已经存在的对象。
3. 函数接受输入参数（例如，+ 的两侧）和输出参数（将结果放在哪里，覆盖之前对象中的所有内容），如下所示：

mpz_add (a, a, b); /* a=a+b */

这样您将始终清楚地看到对象何时被创建/销毁，并且可以确保没有泄漏或双重释放。当然，这会阻止您将多个操作“链接”在一起，并使您手动管理临时变量以获得中间结果。但是，我相信您仍然必须在 C 中手动执行此操作，因为即使是编译器也不太了解动态分配变量的生命周期。

实际上，如果我们不离开。 3 并添加“库不管理内存”子句，我们将得到更容易出错的解决方案（从库的角度来看），这将要求库的用户随心所欲地管理内存。这样你也不会用malloc/free内存分配锁定用户，这是一件好事。

Answer 2

无需动态分配四元数。四元数具有固定的大小，因此您可以只使用普通的四元数。如果您进行整数计算，您也可以只使用ints，而无需为每个int 动态分配空间。

不使用malloc/free的想法（未经测试的代码）

Quaternion quaternion_create(float nw, float nx, float ny, float nz) {
    Quaternion q;

    q.w = nw;
    q.x = nx;
    q.y = ny;
    q.z = nz;
    return q;
}

Quaternion quaternion_get_product(Quaternion *this, Quaternion *p) {
    Quaternion return_q = quaternion_create(
        this->w * p->w - this->x * p->x - this->y * p->y - this->z * p->z,  // new w
        this->w * p->x + this->x * p->w + this->y * p->z - this->z * p->y,  // new x
        this->w * p->y - this->x * p->z + this->y * p->w + this->z * p->x,  // new y
        this->w * p->z + this->x * p->y - this->y * p->x + this->z * p->w
    );
    return return_q;
}

用法

Quaternion p = quaternion_create(1, 0, 0, 0);
Quaternion q = quaternion_create(1, 0, 1, 0);
Quaternion r = quaternion_create(1, 1, 1, 0);
Quaternion s = quaternion_create(1, 1, 1, 1);

p = quaterion_get_product(&p, &q);

Quaternion t = quaternion_get_product(&q, quaternion_get_product(&s, &r)); 

没有mallocs 也没有frees 所以不存在内存泄漏的可能，性能会更好。

Answer 3

在我看来你说错了。

您还需要检查 malloc() 是否返回 NULL 并处理该故障（例如通过显示内存不足错误消息并在失败时退出，因为这通常是不可恢复的）。

更新：

由于您需要释放中间结果，因此您必须采取更多措施来保留指针。

更新 2

@MichaelWalz 的方法很棒。如果不需要，为什么要处理所有分配和指针管理？但是，如果您确实使用指针并分配内存，则必须保留指针并确保释放内容并小心地传递/重用它们。我更新了我的示例来处理嵌套调用。

更新 3

我不得不从函数调用参数中删除 &'s，因为你传入的指针已经是你想要指向的地址。您没有正确分配函数的输出。请注意，固定示例中的指针分配也有所不同。

---

Quaternion p = *quaternion_create(1, 0, 0, 0);
Quaternion q = *quaternion_create(1, 0, 1, 0);
Quaternion r = *quaternion_create(1, 1, 1, 0);
Quaternion s = *quaternion_create(1, 1, 1, 1);

p = *quaterion_get_product(&p, &q); // Memory leak, old p memory block is not being pointed by anyone

Quaternion t = *quaternion_get_product(&q, quaternion_get_product(&s, &r)); 

---

Quaternion *p = quaternion_create(1, 0, 0, 0);
Quaternion *q = quaternion_create(1, 0, 1, 0);
Quaternion *r = quaternion_create(1, 1, 1, 0);
Quaternion *s = quaternion_create(1, 1, 1, 1);


Quaternian *tmp = quaterion_get_product(p, q); 
quaternian_destroy(p);
p = tmp;
tmp = quaternion_get_product(s, r)
Quaternion *t = quaternion_get_product(q, tmp); 
quaternian_destroy(tmp);