C或C ++析构函数中模拟GO语言延迟的实用方法是什么？

Question

In short: it is a smart pointers in C question. Reason: embedded programming and need to ensure that if complex algorithm is used, then proper deallocation occurs with little effort on the developer side.

My favorite feature of C++ is ability to execute a proper deallocation of object allocated on stack and that goes out of scope. GO language defer provides same functionality and it is a bit closer in spirit to C.

GO defer would be the desired way of doing things in C. Is there a practical way to add such functionality?

The goal of doing so is simplification of tracking when and where object goes out of scope. Here is a quick example:

struct MyDataType *data = malloc(sizeof(struct MyDataType));
defer(data, deallocator);
if (condition) {
    // dallocator(data) is called automatically
    return;
}
// do something
if (irrelevant) {
    struct DT *localScope = malloc(...);
    defer(localScope, deallocator);
    // deallocator(localScope) is called when we exit this scope
}
struct OtherType *data2 = malloc(...);
defer(data2, deallocator);
if (someOtherCondition) {
    // dallocator(data) and deallocator(data2) are called in the order added
    return;
}

In other languages I could create an anonymous function inside the code block, assign it to the variable and execute manually in front of every return. This would be at least a partial solution. In GO language defer functions can be chained. Manual chaining with anonymous functions in C is error prone and impractical.

Thank you

Answer 1

C does not have destructors (unless you think of the GCC specific variable attribute cleanup, which is weird and rarely used; notice also that the GCC function attribute destructor is not what other languages, C++ notably, call destructor). C++ have them. And C & C++ are very different languages.

In C++11, you might define your class, having a std::vector or std::function-s, initialized using a std::initialized_list of lambda expressions (and perhaps dynamically augmented by some push_back). Then its destructor could mimic Go's defer-ed statements. But this is not idiomatic.

Go have defer statements and they are idiomatic in Go.

I recommend sticking to the idioms of your programming languages.

^{(In other words: don't think in Go while coding in C++)}

You could also embed some interpreter (e.g. Lua or Guile) in your application. You might also learn more about garbage collection techniques and concepts and use them in your software (in other words, design your application with its specific GC).

Reason: embedded programming and need to ensure that if complex algorithm is used, then proper deallocation occurs with little effort on the developer side.

You might use arena-based allocation techniques, and de-allocate the arena when suitable... When you think about that, it is similar to copying GC techniques.

---

Maybe you dream of some homoiconic language with a powerful macro system suitable for meta-programming. Then look into Common Lisp.