悬空指针和双重释放

Question

经过一些痛苦的经历，我明白了悬空指针和双重释放的问题。我正在寻求适当的解决方案。

aStruct 有许多字段，包括其他数组。

aStruct *A = NULL, *B = NULL;
A = (aStruct*) calloc(1, sizeof(sStruct));
B = A;
free_aStruct(A);
...
// Bunch of other code in various places.
...
free_aStruct(B);

有没有办法编写 free_aStruct(X) 以便 free_aStruct(B) 正常退出？

void free_aStruct(aStruct *X) {
    if (X ! = NULL) {
        if (X->a != NULL) { free(X->a); x->a = NULL; }
        free(X); X = NULL;
    }
}

执行上述操作仅在调用 free_aStruct(A); 时设置 A = NULL。 B 现在悬空。

如何避免/补救这种情况？引用计数是唯一可行的解​​决方案吗？或者，是否有其他“防御性”方法来释放内存，以防止 free_aStruct(B); 爆炸？

Answer 1

在普通 C 中，解决这个问题最重要的方法是纪律，因为问题的根源就在这里：

B = A;

在不更改结构体中任何内容的情况下制作指针的副本，在没有编译器任何警告的情况下绕过您使用的任何内容。您必须使用这样的东西：

B = getref_aStruct(A);

下一个重要的事情是跟踪分配。一些有帮助的事情是干净的模块化、信息隐藏和 DRY——不要重复自己。您可以直接调用 calloc() 来分配内存，同时使用 free_aStruct() 函数来释放内存。最好使用 create_aStruct() 来分配它。这使得事情集中在一个地方，而不是在整个代码库中分配内存。

对于您在此基础上构建的任何内存跟踪系统来说，这都是一个更好的基础。

Answer 2

我不认为你可以自动执行此操作，因为 C 将管理内存的责任和负担交给你，因此你有责任确保引用和悬空指针得到照顾！

void free_aStruct(aStruct *X){
  if (X ! = NULL){
      if (X->a != NULL){free(X->a); x->a = NULL;}
      free(X); X = NULL;
}
}

顺便说一句，上面的 if 检查中有一个拼写错误...使用小写的“x”而不是“X”...

当我查看上面的代码时，我的想法是您正在对 aStruct * 类型的指针变量的副本进行释放。我会将其修改为按引用调用...

void free_aStruct(aStruct **X){
  if (*X ! = NULL){
      if (*X->a != NULL){
          free(*X->a); 
          *X->a = NULL;
      }
      free(*X); 
      *X = NULL;
  }
}

并这样调用它：

free_aStruct(&A);

除此之外，您最终要自己对“悬空指针”负责，无论是无意的编码还是设计错误...

Answer 3

即使您可以防止 free_aStruct(B) 爆炸，如果您的注释后面的代码中有任何对 B 的引用，那么这将使用已释放的内存，因此随时可能会被新数据覆盖。仅“修复”免费调用只会掩盖潜在的错误。

Answer 4

您可以使用一些技术，但底线是您所做的任何事情都无法在 C 中严格执行。相反，我建议在您的开发过程中合并 valgrind （或 purify）。此外，一些静态代码分析器可能能够检测其中一些问题。

Answer 5

引用计数实际上并不那么难：（

aStruct *astruct_getref(aStruct *m)
{
    m->refs++;
    return m;
}

aStruct *astruct_new(void)
{
    sStruct *new = calloc(1, sizeof *new);
    return astruct_getref(new);
}

void astruct_free(aStruct *m)
{
    if (--m->refs == 0)
        free(m);
}

在多线程环境中，您还可能需要添加锁定）。

那么你的代码将是：

aStruct *A = NULL, *B = NULL;
A = astruct_new();
B = astruct_getref(A);
astruct_free(A);
...
//bunch of other code in various places.
...
astruct_free(B);

---

你已经询问了锁定。不幸的是，当涉及到锁定时，没有一刀切的答案 - 这完全取决于您的应用程序中的访问模式。精心的设计和深刻的思考是无可替代的。 （例如，如果您可以保证没有线程会在另一个线程的 aStruct< 上调用 astruct_getref() 或 astruct_free() /code>，那么引用计数根本不需要受到保护 - 上面的简单实现就足够了）。

也就是说，上述原语可以轻松扩展以支持对 astruct_getref() 和 astruct_free() 函数的并发访问：

aStruct *astruct_getref(aStruct *m)
{
    mutex_lock(m->reflock);
    m->refs++;
    mutex_unlock(m->reflock);
    return m;
}

aStruct *astruct_new(void)
{
    sStruct *new = calloc(1, sizeof *new);
    mutex_init(new->reflock);
    return astruct_getref(new);
}

void astruct_free(aStruct *m)
{
    int refs;

    mutex_lock(m->reflock);
    refs = --m->refs;
    mutex_unlock(m->reflock);
    if (refs == 0)
        free(m);
}

...但请注意，任何包含指针的变量受并发访问影响的结构也需要自己的锁定（例如，如果您有一个并发访问的全局 aStruct *foo ，则它将需要一个附带的 foo_lock代码>）。