C语言创建和使用不透明指针

什么是不透明指针

不透明指针是一种指针类型，在定义时不指定指向的数据类型，编译器无法确定指针所指向的数据的内存大小和类型，从而使得指向的数据对用户来说是不可见的，只有通过特定的函数接口才能访问到对应的数据。

不透明指针的常见应用场景是在某些库中，对外部提供一些数据类型，但是不希望把具体的实现细节暴露给外部使用者。

不透明指针的创建

不透明指针的创建需要定义一个结构体类型，并在结构体类型中保存具体数据的指针。然后编写一组函数，这些函数用于操作这个结构体类型，从而对内部的具体数据进行操作。而这些函数只是用于访问这个结构体类型，对外面使用者来说，结构体类型的内部是不可见的，只有通过这些接口函数来操作。

以创建一个字符串类型为例，定义一个结构体类型 string_t，并在结构体中保存一个 char 类型的指针，如下所示：

// string.h
typedef struct string_t *string;

string string_create(const char *str); // 创建字符串
void string_destroy(string s); // 销毁字符串
void string_copy(string s1, string s2); // 复制字符串

在实现文件中，我们需要实现这些函数，如下所示：

// string.c
#include "string.h"
#include <stdlib.h>
#include <string.h>

struct string_t {
    char *str;
};

string string_create(const char *str) {
    string s = malloc(sizeof(struct string_t));
    s->str = malloc(strlen(str) + 1);
    strcpy(s->str, str);
    return s;
}

void string_destroy(string s) {
    free(s->str);
    free(s);
}

void string_copy(string s1, string s2) {
    strcpy(s1->str, s2->str);
}

在以上代码中，我们创建了一个 string_t 的结构体类型，并用 typedef 定义了一个 string 类型的不透明指针。同时，我们实现了三个函数：string_create、string_destroy 和 string_copy。其中，string_create 函数用于创建一个字符串，string_destroy 用于销毁字符串，string_copy 用于复制字符串。

不透明指针的使用

在使用不透明指针时，用户只能调用我们提供的接口函数，而不能直接操作结构体类型的内部数据。例如，在使用上述 string_t 类型时，用户只能使用 string_create、string_destroy 和 string_copy 这三个函数，而不能直接访问 string_t 中的 str 指针。

下面是一个示例代码，演示了如何使用上述的字符串类型：

#include <stdio.h>
#include "string.h"

int main() {
    string s1 = string_create("hello world");
    string s2 = string_create("this is a test");

    printf("s1 = %s\n", s1->str);
    printf("s2 = %s\n", s2->str);

    string_copy(s1, s2);

    printf("s1 = %s\n", s1->str);
    printf("s2 = %s\n", s2->str);

    string_destroy(s1);
    string_destroy(s2);

    return 0;
}

在这段示例代码中，我们调用了 string_create 函数创建了两个字符串 s1 和 s2，并输出了它们的值。然后使用 string_copy 函数将 s2 的值复制到了 s1 中，并输出了结果。最后，我们使用 string_destroy 函数销毁了这两个字符串。

应用示例

下面再给出一个应用示例。我们定义一个数组类型，数组中的元素由使用者指定，但是数组的大小由库内部自己管理，使用者只能通过提供的函数接口访问和操作这个数组。

// array.h
typedef struct array_t *array;

array array_create(int size); // 创建数组
void array_destroy(array a); // 销毁数组
int array_get_size(array a); // 获取数组大小
void array_set_element(array a, int i, int element); // 设置数组元素
int array_get_element(array a, int i); // 获取数组元素

在实现文件中，我们需要实现这些函数，如下所示：

// array.c
#include "array.h"
#include <stdlib.h>

struct array_t {
    int size;
    int *data;
};

array array_create(int size) {
    array a = malloc(sizeof(struct array_t));
    a->size = size;
    a->data = malloc(sizeof(int) * size);
    return a;
}

void array_destroy(array a) {
    free(a->data);
    free(a);
}

int array_get_size(array a) {
    return a->size;
}

void array_set_element(array a, int i, int element) {
    if (i >= 0 && i < a->size) {
        a->data[i] = element;
    }
}

int array_get_element(array a, int i) {
    if (i >= 0 && i < a->size) {
        return a->data[i];
    }
    else {
        return 0;
    }
}

在以上代码中，我们创建了一个 array_t 的结构体类型，并用 typedef 定义了一个 array 类型的不透明指针。同时，我们实现了五个函数：array_create、array_destroy、array_get_size、array_set_element 和 array_get_element。其中，array_create 函数用于创建一个数组，array_destroy 用于销毁数组，array_get_size 用于获取数组大小，array_set_element 用于设置数组元素，array_get_element 用于获取数组元素。

下面是一个示例代码，演示了如何使用上述的数组类型：

#include <stdio.h>
#include "array.h"

int main() {
    array a = array_create(10);

    printf("Array size: %d\n", array_get_size(a));

    for (int i = 0; i < array_get_size(a); i++) {
        array_set_element(a, i, i * i);
    }

    for (int i = 0; i < array_get_size(a); i++) {
        printf("%d ", array_get_element(a, i));
    }
    printf("\n");

    array_destroy(a);

    return 0;
}

在这段示例代码中，我们调用了 array_create 函数创建了一个大小为 10 的数组，并输出了数组的大小。然后使用 array_set_element 函数设置了数组的元素。最后，我们使用 array_get_element 函数获取数组的元素并输出了结果。最后，我们使用 array_destroy 函数销毁了这个数组。

总结

不透明指针可以用于实现库中的数据类型，隐藏内部实现细节，提供简洁的接口给外部调用。使用不透明指针需要定义结构体类型和一组函数接口，从而操作结构体类型内部的数据。使用者只能通过这些接口函数访问和操作数据，而不能直接操作结构体类型内部的数据。