Question

是否可以在纯C中实现RAII？

我认为不可能以任何理智的方式，但也许可能使用某种肮脏的技巧。重载标准free函数会想到或者可能覆盖堆栈上的返回地址，这样当函数返回时，它会调用一些以某种方式释放资源的其他函数？或者也许有一些setjmp / longjmp技巧？

这纯粹是学术上的兴趣，我无意写出这种不可移植和疯狂的代码，但我想知道这是否可能。

Answer 1

这是固有的实施依赖，因为标准不包括这种可能性。对于GCC，cleanup属性在变量超出范围时运行函数：

#include <stdio.h>

void scoped(int * pvariable) {
    printf("variable (%d) goes out of scope\n", *pvariable);
}

int main(void) {
    printf("before scope\n");
    {
        int watched __attribute__((cleanup (scoped)));
        watched = 42;
    }
    printf("after scope\n");
}

打印：

before scope
variable (42) goes out of scope
after scope

请参阅here

Answer 2

将RAII引入C（当你没有cleanup()时）的一个解决方案是使用将执行清理的代码包装函数调用。这也可以打包在一个整洁的宏（最后显示）。

/* Publicly known method */
void SomeFunction() {
  /* Create raii object, which holds records of object pointers and a
     destruction method for that object (or null if not needed). */
  Raii raii;
  RaiiCreate(&raii);

  /* Call function implementation */
  SomeFunctionImpl(&raii);

  /* This method calls the destruction code for each object. */
  RaiiDestroyAll(&raii);
}

/* Hidden method that carries out implementation. */
void SomeFunctionImpl(Raii *raii) {
  MyStruct *object;
  MyStruct *eventually_destroyed_object;
  int *pretend_value;

  /* Create a MyStruct object, passing the destruction method for
     MyStruct objects. */
  object = RaiiAdd(raii, MyStructCreate(), MyStructDestroy);

  /* Create a MyStruct object (adding it to raii), which will later
     be removed before returning. */
  eventually_destroyed_object = RaiiAdd(raii,
      MyStructCreate(), MyStructDestroy);

  /* Create an int, passing a null destruction method. */
  pretend_value = RaiiAdd(raii, malloc(sizeof(int)), 0);

  /* ... implementation ... */

  /* Destroy object (calling destruction method). */
  RaiiDestroy(raii, eventually_destroyed_object);

  /* or ... */
  RaiiForgetAbout(raii, eventually_destroyed_object);
}

您可以使用宏来表达SomeFunction中的所有样板代码，因为每次调用它都是相同的。

例如：

/* Declares Matrix * MatrixMultiply(Matrix * first, Matrix * second, Network * network) */
RTN_RAII(Matrix *, MatrixMultiply, Matrix *, first, Matrix *, second, Network *, network, {
  Processor *processor = RaiiAdd(raii, ProcessorCreate(), ProcessorDestroy);
  Matrix *result = MatrixCreate();
  processor->multiply(result, first, second);
  return processor;
});

void SomeOtherCode(...) {
  /* ... */
  Matrix * result = MatrixMultiply(first, second, network);
  /* ... */
}

注意：您希望使用P99之类的高级宏框架来实现上述功能。

Answer 3

如果您的编译器支持C99（甚至是其中很大一部分），您可以使用可变长度数组（VLA），例如：

int f(int x) { 
    int vla[x];

    // ...
}

如果内存服务，gcc在添加到C99之前已经/支持此功能。这（大致）等同于：

的简单情况

int f(int x) { 
    int *vla=malloc(sizeof(int) *x);
    /* ... */
    free vla;
}

但是，它不允许您执行dtor可以执行的任何其他操作，例如关闭文件，数据库连接等。

Answer 4

可能最简单的方法是使用goto跳转到函数末尾的标签，但这对于你正在看的东西来说可能太过手动了。

Answer 5

我选择覆盖堆栈上的返回地址。它是最透明的。替换free仅适用于堆分配的“对象”。

Answer 6

你看过alloca（）吗？当var离开范围时它将自由。但要有效地使用它，调用者必须在发送之前始终执行alloca ...如果你实现了strdup，那么你就不能使用alloca。

Answer 7

嘿，你正试图重新创建CFront！

Answer 8

检查https://github.com/psevon/exceptions-and-raii-in-c以获取唯一且共享的智能指针和例外的C实现。此实现依赖于宏括号BEGIN ... END替换括号并检测超出范围的智能指针，以及返回的宏替换。

Answer 9

之前我还不知道属性清理。当然它是一个适用的简洁解决方案，但它似乎在基于setjmp / longjmp的异常实现中表现良好;对于抛出异常的范围和捕获异常的范围之间的任何中间范围/函数，不会调用cleanup函数。 Alloca没有这个问题，但是对于alloca，你不能将内存块的所有权从调用它的函数转移到外部作用域，因为内存是从堆栈帧分配的。可以实现类似于C ++ unique_ptr和shared_ptr的智能指针，认为它需要使用宏括号而不是{}并返回以便能够将额外的逻辑与范围进入/退出相关联。有关实现，请参阅https://github.com/psevon/exceptions-and-raii-in-c中的autocleanup.c。

Answer 10

补充约翰内斯答案的这一部分：

当变量超出范围
时，cleanup属性会运行一个函数

清理属性（http://gcc.gnu.org/onlinedocs/gcc-4.0.4/gcc/Variable-Attributes.html）有一个限制：此属性只能应用于自动函数范围变量。

因此，如果文件中存在静态变量，则可以通过这种方式为静态变量实现RAII：

#include <stdio.h>
#include <stdlib.h>

static char* watched2;

__attribute__((constructor))
static void init_static_vars()
{
  printf("variable (%p) is initialazed, initial value (%p)\n", &watched2, watched2);
  watched2=malloc(1024);
}


__attribute__((destructor))
static void destroy_static_vars()
{
  printf("variable (%p), value( %p) goes out of scope\n", &watched2, watched2);
  free(watched2);
}

int main(void)
{
  printf("exit from main, variable (%p) value(%p) is static\n", &watched2, watched2);
  return 0;
}

这是一个测试：

>./example
variable (0x600aa0) is initialazed, initial value ((nil))
exit from main, variable (0x600aa0) value(0x16df010) is static
variable (0x600aa0), value( 0x16df010) goes out of scope

Answer 11

my implementation of raii for c in pure c and minimal asm
@ https://github.com/smartmaster/sml_clang_raii

**RAII for C language in pure C and ASM**

**featurs : **

-easy and graceful to use
- no need seperate free cleanup functions
- able to cleanup any resources or call any function on scope exits


**User guide : **

-add source files in src folder to your project
-include sml_raii_clang.h in.c file
-annote resource and its cleanup functions

/ * 样例代码 * /

void sml_raii_clang_test()
{
    //start a scope, the scope name can be any string
    SML_RAII_BLOCK_START(0);


    SML_RAII_VOLATILE(WCHAR*) resA000 = calloc(128, sizeof(WCHAR)); //allocate memory resource
    SML_RAII_START(0, resA000); //indicate starting a cleanup code fragment, here 'resA000' can be any string you want
    if (resA000) //cleanup code fragment
    {
        free(resA000);
        resA000 = NULL;
    }
    SML_RAII_END(0, resA000); //indicate end of a cleanup code fragment


    //another resource
    //////////////////////////////////////////////////////////////////////////
    SML_RAII_VOLATILE(WCHAR*) res8000 = calloc(128, sizeof(WCHAR));
    SML_RAII_START(0, D000);
    if (res8000)
    {
        free(res8000);
        res8000 = NULL;
    }
    SML_RAII_END(0, D000);


    //scope ended, will call all annoated cleanups
    SML_RAII_BLOCK_END(0);
    SML_RAII_LABEL(0, resA000); //if code is optimized, we have to put labels after SML_RAII_BLOCK_END
    SML_RAII_LABEL(0, D000);
}

在纯C中实现RAII？

11 个答案: