c++ - 在闭包中，如何通过指针或引用类型捕获的可变变量存储在内存中或以现代功能语言处理？

Question

Closed. This question needs to be more focused。它当前不接受答案。












想改善这个问题吗？更新问题，使其仅关注 editing this post的一个问题。

2年前关闭。



Improve this question




我正在写Transpiler，用于教育目的。
我的翻译员从我的语言过渡到C语言。
我现在正在编写闭包语法分析器和代码生成组件。

我看到有人说，C++中的闭包实际上已转换为未命名的结构类型，其中捕获的值作为变量在内部。

Here is the reference。

此代码

int c = 10;
auto closure = [=] () -> void {
    std::cout << c << std::endl;
};

他们说，基本上是在幕后将其转变为类似这样的东西。

struct UNNAMED_TYPE_0 {
    int c;

    void operator() () const {
        std::cout << c << std::endl;
    }
};
// assume the closure is initialized and variables are assigned

如果有人想在执行闭包时更改该 int c，则他/她必须将此变量作为ref [&c] () -> void { /* mutation comes here */}传递。但是问题是，如果我们在函数内部声明 int c并像这样在函数内部创建该闭包

function<void()> aFunction() {
    int c = 10;
    auto closure = [&c] () -> void { c = 100; }
    return closure;
}

aFunction() ();

捕获了 int c，但是一旦 aFunction堆栈被破坏，该 int c也将被破坏。这意味着，如果我们尝试在释放的地址上进行写入，则可能希望运行 segmentation fault(core dumped)指针错误。

在 Java 中，

// suppose this callback interface exists
public interface VoidCallback {
    public void method();
} 


public void aMethod() {
    int c = 10;
    VoidCallback callback = () -> c = 10; /* this gives an error */
    // local variables referenced from a lambda expression must be final or effectively final
}

Java这样处理闭包，并确保闭包捕获不发生任何变化(假设隐式捕获)。这意味着Java通过闭包捕获的是副本而不是ref。对于引用或类类型，仅将Object指针作为副本传递。尽管指针引用不会更改，但是您可以更改指针指向的对象内的内容。这基本上与以前的相同。

在 Objective-C 中，

__block int c = 0;
// they say, this `int c` is allocated in heap instead of stack
// so that it exists until the closure is finished executing.
void (^ closure) (void) = ^void() {
    c = 10; // this is valid
    // this actually changed the `int c`'s value
}; 

在 中Swift

var a : Int = 10;
var closure = { [] () -> Void in
    a = 10; // this is valid by default
    // unless `var a` is declared as `let a`
};

因此，这意味着，Objective-C和Swift将原始捕获列表分配为指针。使它们可以被突变。

附注:请注意，Swift闭包捕获列表仅适用于类或引用类型，但我的意思是此处隐式捕获原始类型。

这是

__block int c = 0;
// they say, this `int c` is allocated in heap instead of stack
// so that it exists until the closure is finished executing.
void (^ closure) (void) = ^void() {
    c = 10; // this is valid
    // this actually changed the `int c`'s value
}; 

与此(基本上)相同

int * c = malloc(sizeof(int));
*c = 0;
void (^ closure) (void) = ^void() {
    *c = 10;
    if (c) {
        free(c);
        c = NULL;
    }
}; 

我认为关闭完成后立即释放指针变量将太糟糕了。
如果有很多闭包指向变量并且在执行时会发生变化，该怎么办？
如果这些闭包在不同的线程之间传递或执行，该怎么办？

我想出了使用引用计数技术的解决方案。
当创建一个使变量变异的闭包时，该变量将被保留。
当使变量变异的闭包被破坏时，变量将被释放。
没有闭包时，变量将被真正释放。
为了确保线程安全，我将在闭包操纵引用计数技术时锁定和解锁计数器变量地址。

如果还有其他技术，请指导我。
任何语言的任何解释将不胜感激。

目前，我对汇编语言的知识为零。

对于主持人，
因为这个问题是一种研究，所以请您不要将其标记为过于广泛。

最佳答案

以下内容令我印象深刻:“我正在出于教育目的编写Transpiler。我的Transpiler从我的语言转换为C语言。”现在，这意味着您的语言规范定义了语言的工作方式!我们无法告诉您您的语言应该如何运作。

现在，您已经找到了很多选择:

C++对局部变量不做任何特殊处理。如果您保留对它的引用并在超出范围时使用它，那么运气不好。这是C++的精神，不给您带来任何负担，但是如果您不注意的话，也可以让您脚踏实地。

Java仅检查代码，并告诉您是否尝试执行它认为不能保证有效的任何操作，否则会给您错误。即使您非常想要它，也不允许您用脚射击自己。

其他语言似乎将范围有限的局部变量转换为基于堆的变量。我不确定他们的对象模型，但是例如在Python中，您根本没有与C++局部变量或Java原语类型相似的东西，就像您没有确定性的析构函数调用一样(为了完整起见，您使用with获得了类似的东西)，所以这没有做任何区别。这些语言会给您带来额外的负担，以确保您没有任何悬而未决的引用(即使您确实不需要它)。

现在，首先要确定哪种语言最适合您的语言的对象模型。只有这样，问题才会出现，如何最好地实现它。关于实现，有很多不同的方法。使用引用计数器是一个(使用无锁的原子操作来实现)，使用链接列表是另一个，或者使用垃圾收集器。

关于c++ - 在闭包中，如何通过指针或引用类型捕获的可变变量存储在内存中或以现代功能语言处理？ ，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/48146679/

上一篇：ios - 如何显示结果小数样式而不是指数？

下一篇：ios - 如何使用枚举制作切换开关

相关文章：

ios - 使 AppDelegate 接收来自自定义库的回调事件

ios - 解析不保存字段

ios - 使用 Swift 在 ios 中保存应用程序的状态

c++ - 使用三元运算符初始化引用变量？

c++ - Eigen Jacobi 在 C++ 中导致奇怪的段错误

ios - Xcode 不在模拟器上运行该应用程序。 (应用程序意外退出)

iphone - UITextView 在第一次点击时不显示 InputAccessoryView

c++ - 所有权/删除区域设置中的构面(std::locale)

c++ - C++中的智能指针引用计数

swift - AppleTv/TvOS - 调整保存到 ImageURL 的 TVContentItems 中 TopShelf 图像的大小

Answer 1

以下内容令我印象深刻:“我正在出于教育目的编写Transpiler。我的Transpiler从我的语言转换为C语言。”现在，这意味着您的语言规范定义了语言的工作方式!我们无法告诉您您的语言应该如何运作。

现在，您已经找到了很多选择:

C++对局部变量不做任何特殊处理。如果您保留对它的引用并在超出范围时使用它，那么运气不好。这是C++的精神，不给您带来任何负担，但是如果您不注意的话，也可以让您脚踏实地。

Java仅检查代码，并告诉您是否尝试执行它认为不能保证有效的任何操作，否则会给您错误。即使您非常想要它，也不允许您用脚射击自己。

其他语言似乎将范围有限的局部变量转换为基于堆的变量。我不确定他们的对象模型，但是例如在Python中，您根本没有与C++局部变量或Java原语类型相似的东西，就像您没有确定性的析构函数调用一样(为了完整起见，您使用with获得了类似的东西)，所以这没有做任何区别。这些语言会给您带来额外的负担，以确保您没有任何悬而未决的引用(即使您确实不需要它)。

现在，首先要确定哪种语言最适合您的语言的对象模型。只有这样，问题才会出现，如何最好地实现它。关于实现，有很多不同的方法。使用引用计数器是一个(使用无锁的原子操作来实现)，使用链接列表是另一个，或者使用垃圾收集器。