所有权与生命周期解析

C 语言允许我们定义变量,例如:

// 在函数内部声明的变量通常存储在栈上。
int a = 42;

// 使用 `static` 声明或在文件作用域声明的变量通常存储在 `.data`
// 或 `.rodata` 段中。
static int b = 2026;

这些变量所使用的存储空间由语言本身管理。然而,有时我们需要手动管理内存。在这种情况下,我们可以使用 malloc()、calloc() 和 realloc() 等函数来获取动态分配的内存。

// 动态分配的内存通常来自堆。
int *c = malloc(sizeof *c);
*c = 42;

当内存不再需要时,我们使用 free() 释放它。

free(c);

这样,我们便可以根据需要灵活地分配和释放内存,从而实现各种复杂的数据结构,以及许多仅使用静态分配内存时难以实现甚至无法实现的功能。

然而,这种方式也带来了一个问题。

考虑下面这种情况:

int *a = malloc(sizeof *a);
int *b = a;

究竟应该由谁负责释放这块内存?

显然,既不释放这块内存,也不是解决方案,因为这会导致内存泄漏。同样,通过两个指针分别释放这块内存也不可取,因为这会导致 ISO/IEC 9899 所规定的未定义行为,通常称为重复释放。

我们应该只通过这两个指针中的一个来释放这块内存。但我们该如何确定应该使用哪一个呢?这就引出了内存管理乃至一般资源管理中的一个重要概念:所有权。

所有权、借用与转移

所有权是一种约定,用于规定程序中的哪个部分负责管理某项资源,并在资源不再需要时将其释放。如果某个指针变量根据约定负责调用 free() 释放相应的内存,我们就称该指针变量拥有这块内存。

为了说明所有权如何帮助我们正确地管理资源,让我们实现一个链表。首先,定义如下结构体:

typedef struct N
{
    int data;
    struct N *previous;
    struct N *next;
} Node;

我们使用 previous == NULL 表示守卫节点(其成员 data 没有实际意义),使用 next == NULL 表示链表的最后一个节点。

假设我们在文件作用域定义了一个 Node 变量,并将其用作守卫节点:

Node l = {0, NULL, NULL};

我们需要一些函数来操作这个链表。

定义以下函数:

Node *getNode(Node *guard, int index)
{
    if (index < 0)
        return NULL;  // 索引为负数。
    else if (index > 0 && guard->next == NULL)
        return NULL;  // 索引超出范围。
    else if (index == 0)
        return guard->next;
    else return getNode(guard->next, index - 1);
}

void setData(Node *x, int data)
{
    x->data = data;
}

int getData(Node *x)
{
    return x->data;
}

下面是我们在 main() 函数中的一些语句:

/* ... */

Node *a = malloc(sizeof *a);
a->previous = NULL;
a->next = NULL;
setData(a, 42);
printf("%d\n", getData(a));

/* ... */

在调用 setData() 和 getData() 之后,究竟应该由谁负责释放 a 所指向的内存?显然,责任仍然属于 a。setData() 和 getData() 只会读取或修改通过参数传递给它们的内存,既不会分配内存,也不会释放内存。它们也不会将这些指针传递给其他负责管理这块内存的函数,或存储到负责管理这块内存的全局变量中。因此,我们称这些函数借用了这块内存,而不是取得了它的所有权。

借用是指函数获得访问某项资源的权限,但不承担管理其生命周期的责任。根据接口约定,函数可以读取或修改该资源,但不能自行释放它。

getNode() 也是如此:它遍历链表,并根据索引获取相应的节点。它既不分配也不释放内存,也不会转移任何资源的所有权。

不过,情况并不总是如此。考虑下面这些函数:

Node *createNode(int data)
{
    Node *ans = malloc(sizeof *ans);
    if (! ans)
        exit(EXIT_FAILURE);
    ans->data = data;
    ans->previous = NULL;
    ans->next = NULL;
    return ans;
}

int insertNode(Node *guard, Node *n, int index)
{
    if (index < 0)
        return 1;  // 索引为负数。
    else if (index > 0 && guard->next == NULL)
        return 2;  // 索引超出范围。
    else if (index == 0)
    {
        if (guard->next)
        {
            n->next = guard->next;
            guard->next->previous = n;
        }
        n->previous = guard;
        guard->next = n;
        return 0;
    }
    else return insertNode(guard->next, n, index - 1);
}

现在,我们可以将 a 传递给 insertNode(),把已经分配的节点插入链表:

/* ... */

insertNode(&l, a, 0);

/* ... */

接下来会发生什么?

显然,在 insertNode() 成功执行之后,我们不应该再调用 free(a),否则就会破坏链表。相反,应该在销毁链表时释放这个节点:

void destroyExceptGuard(Node *guard)
{
    if (guard == NULL)
        return;

    Node *current = guard->next;
    guard->next = NULL;

    while (current != NULL)
    {
        Node *next = current->next;
        free(current);
        current = next;
    }
}

当 insertNode() 成功插入一个节点时,该节点的所有权便从调用者转移到了链表。这个函数负责执行所有权转移,但插入完成后,链表才是负责管理该节点的一方。

createNode() 则执行相反的操作:它分配内存并返回一个指向该内存的指针。函数返回之后,它便不再负责释放这块内存。相反,这项责任转交给了接收返回指针的调用者。我们称这一过程为函数向调用者转移所有权。

生命周期——资源应当存续多久?

拥有所有权意味着,所有者不仅负责释放内存,还负责决定何时释放内存。换句话说,所有者决定了资源的生命周期。

更一般地说,所有权是一种编程约定,它规定程序中的哪个部分负责管理某项资源的生命周期,尤其是在资源不再需要时负责释放它。一个指针可以指向某项资源而不拥有它,并且多个指针也可以指向同一项资源。

在 C 语言中,动态分配存储空间中的对象的生命周期由 free() 以及其他可能改变内存分配状态的函数管理。对象从内存分配时开始存在,直到其中一个函数作用于这块内存为止。

让我们重新看看链表节点的定义:

typedef struct N
{
    int data;
    struct N *previous;
    struct N *next;
} Node;

一个完整且结构正确的链表应该包含一个守卫节点,以及若干通过指针正确连接起来的元素节点。如果在释放某个节点之前没有先更新相关指针,那么相邻节点可能仍然保留着指向一个生命周期已经结束的对象的指针值。这些指针值不得再被使用。因此,通过这些指针关系遍历链表可能导致未定义行为。此外,从守卫节点开始遍历链表时,被销毁节点之后的节点也可能变得无法访问。

通常,当我们讨论指针的生命周期时,实际上指的是指针所指向对象的生命周期,而不是指针变量本身的生命周期。指针变量也有自己的生命周期,但二者彼此独立,指针变量的生命周期并不决定其所指对象的生命周期。

生命周期问题并不局限于由程序员管理生命周期的动态分配内存。例如,假设我们将 createNode() 替换为下面的实现:

Node *createNode(int data)
{
    Node ans;
    ans.data = data;
    ans.previous = NULL;
    ans.next = NULL;
    return &ans;
}

这个实现是无效的,因为 ans 的生命周期仅限于函数执行期间。函数返回时,ans 的生命周期便结束了,此时返回的指针已经不再指向一个仍然存在的对象。

给 Node ans 加上 static 也无法解决这个问题。这样做会使 ans 的生命周期延续至整个程序执行期间,但每次调用函数时使用的都是同一个对象,而不是创建一个新的对象。

不同编程语言中的所有权与生命周期

在 C 语言中,所有权并不是由语言本身强制执行的机制,而是程序员为了避免程序崩溃或产生意外行为而自行建立并遵守的一种约定。相比之下,对象的生命周期则是由语言本身定义的。

在某些其他编程语言中,所有权由语言本身强制执行。Rust 就是一个典型例子:它具有由编译器强制执行的所有权系统。每个值都有一个所有者,并且可以通过移动语义在变量之间转移所有权。引用(&T 和 &mut T)允许程序的其他部分借用值,而不取得其所有权。Rust 的生命周期规则确保借用引用不会比其所引用的值存续得更久。例如,String 是一种拥有所有权的类型,它管理着一个用于存储字符串数据的动态分配缓冲区,而 &str 则是一个借用的字符串切片。Rust 还提供了 Rc<T> 和 Arc<T> 等类型,用于实现共享所有权。

C++ 使用 RAII,并结合了自动资源管理与手动管理的方式。我们既可以使用 new 和 delete 手动管理内存,也可以使用 C++ 标准库提供的智能指针,例如 std::unique_ptr<T> 和 std::shared_ptr<T>。这些对象封装了有关动态分配内存所有权的信息,从而让语言能够自动管理资源。我们也可以自行实现智能指针。std::unique_ptr<T> 强制实行独占所有权,其行为类似于 C 中的独占所有权约定,但能够自动管理资源。std::shared_ptr<T> 使用计数器来记录有多少个变量共同拥有某项资源。当不再有变量持有该资源的共享所有权时,它便会自动释放这项资源。

Python 等语言通常采用自动内存管理机制,不要求程序员显式地分配和释放内存。例如,CPython 使用引用计数机制,并结合循环垃圾回收器来管理内存。

使用 Hugo 构建
主题 Stack 由 Jimmy 设计