c - 不透明数据类型的静态分配

Question

在为嵌入式系统编程时，通常绝对不允许使用 malloc()。大多数时候我都能很好地处理这个问题，但有一件事让我很恼火:它阻止我使用所谓的“不透明类型”来启用数据隐藏。通常我会做这样的事情:

// In file module.h
typedef struct handle_t handle_t;

handle_t *create_handle();
void operation_on_handle(handle_t *handle, int an_argument);
void another_operation_on_handle(handle_t *handle, char etcetera);
void close_handle(handle_t *handle);


// In file module.c
struct handle_t {
    int foo;
    void *something;
    int another_implementation_detail;
};

handle_t *create_handle() {
    handle_t *handle = malloc(sizeof(struct handle_t));
    // other initialization
    return handle;
}

好了:create_handle() 执行 malloc() 来创建一个“实例”。通常用于防止必须 malloc() 的构造是像这样更改 create_handle() 的原型(prototype):

void create_handle(handle_t *handle);

然后调用者可以这样创建句柄:

// In file caller.c
void i_am_the_caller() {
    handle_t a_handle;    // Allocate a handle on the stack instead of malloc()
    create_handle(&a_handle);
    // ... a_handle is ready to go!
}

但不幸的是这段代码显然是无效的，handle_t 的大小是未知的!

我从来没有真正找到以正确方式解决这个问题的解决方案。我很想知道是否有人有正确的方法来做到这一点，或者可能是一种完全不同的方法来启用 C 中的数据隐藏(当然不在 module.c 中使用静态全局变量，必须能够创建多个实例).

Answer 1

您可以使用 _alloca 函数。我相信它不完全是标准的，但据我所知，几乎所有常见的编译器都实现了它。当您将它用作默认参数时，它会分配调用者的堆栈。

// Header
typedef struct {} something;
int get_size();
something* create_something(void* mem);

// Usage
handle* ptr = create_something(_alloca(get_size()); // or define a macro.

// Implementation
int get_size() {
    return sizeof(real_handle_type);
}
something* create_something(void* mem) {
    real_type* ptr = (real_type_ptr*)mem;
    // Fill out real_type
    return (something*)mem;
}

您还可以使用某种对象池半堆——如果您有最大数量的当前可用对象，那么您可以静态地为它们分配所有内存，并且只对当前正在使用的对象进行位移。

#define MAX_OBJECTS 32
real_type objects[MAX_OBJECTS];
unsigned int in_use; // Make sure this is large enough
something* create_something() {
     for(int i = 0; i < MAX_OBJECTS; i++) {
         if (!(in_use & (1 << i))) {
             in_use &= (1 << i);
             return &objects[i];
         }
     }
     return NULL;
}

我的移位有点不对劲，我已经很久没做过了，但我希望你能明白我的意思。