blocks|key|5952|text|我认为这里必须使用类而不是结构，因为结构是通过复制传递的，而类是通过引用传递的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5953|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I think you have to use class instead of structure here, because structs are passed by copy and classes by reference

blocks|key|955621|text|为了补充@nikolayn的完美答案，这里有一个可以在控制台中运行的示例，它演示了如何使用类而不是结构(并且也没有数据竞争)来实现这一点：(变量是显式定义的，这样您就可以很容易地调试)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|955622|import+Foundation
import+Cocoa


let+queue+=+dispatch_queue_create("sync_queue",+nil)!

class+Foo+{

++++var+i+=+0+{+didSet+{+println("Current+i:+\(i)")+}+}
++++let+sem+=+dispatch_semaphore_create(0);

++++func+delayedPrint()+{
++++++++let+i_copy+=+i
++++++++let+t+=+dispatch_time(DISPATCH_TIME_NOW,+Int64(1+*+Double(NSEC_PER_SEC)))
++++++++dispatch_after(t,+queue)+{+_+in
++++++++++++let+_i+=+self.i
++++++++++++let+_i_copy+=+i_copy
++++++++++++println("Closure+i:+\(_i)")
++++++++++++println("Closure+i_copy:+\(_i_copy)")
++++++++++++dispatch_semaphore_signal(self.sem)
++++++++}
++++}

++++func+foo()+{
++++++++delayedPrint()
++++++++dispatch_async(queue)+{
++++++++++++self.i%2B%2B
++++++++}
++++}

++++func+wait()+{
++++++++dispatch_semaphore_wait(sem,+DISPATCH_TIME_FOREVER)
++++}
}

var+a+=+Foo()
a.foo()
a.wait()|code-block|syntax|javascript|955623|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

In order to complement @nikolayn perfect answer, here is a sample that can run in the console and that demonstrates how this can be accomplished with a class instead of a struct (and is also free of data races):
(variables are defined explicit so that you can easily debug)

<pre><code>import Foundation
import Cocoa


let queue = dispatch_queue_create("sync_queue", nil)!

class Foo {

 var i = 0 { didSet { println("Current i: \(i)") } }
 let sem = dispatch_semaphore_create(0);

 func delayedPrint() {
 let i_copy = i
 let t = dispatch_time(DISPATCH_TIME_NOW, Int64(1 * Double(NSEC_PER_SEC)))
 dispatch_after(t, queue) { _ in
 let _i = self.i
 let _i_copy = i_copy
 println("Closure i: \(_i)")
 println("Closure i_copy: \(_i_copy)")
 dispatch_semaphore_signal(self.sem)
 }
 }

 func foo() {
 delayedPrint()
 dispatch_async(queue) {
 self.i++
 }
 }

 func wait() {
 dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER)
 }
}

var a = Foo()
a.foo()
a.wait()
</code></pre>

blocks|key|6021|text|我想知道什么是最好的方法，以避免捕获一个象牙副本。|type|blockquote|depth|inlineStyleRanges|entityRanges|data|6022|这是一种误解。你不能以这种方式“捕获一个象牙”。你要捕捉的是self！这就是为什么斯威夫特强迫你说self，这样你才能理解这个事实。因此，self是一种不同的东西。这就是为什么self是一个结构还是一个类很重要的原因。类实例是可变的；struct实例不是，因此在捕获时获取一个副本，并且该副本独立保存。|unstyled|offset|length|style|CODE|6023|但是，您可以捕获一个简单的Int+(即不是ivar)，当您这样做时，您就得到了预期的结果：|6024|var+i+=+0
struct+Foo+{
++++func+delayedPrint()+{
++++++++dispatch_async(dispatch_get_main_queue(),+{
++++++++++++println(i)+//+1
++++++++})
++++}
++++func+foo()+{
++++++++delayedPrint()
++++++++i%2B%2B
++++}
}|code-block|syntax|javascript|6025|现在让我们来谈谈你提出的第二个谜题。这里有一个重写，以澄清谜题是什么：|6026|func+delay(delay:Double,+closure:()->())+{
++++dispatch_after(
++++++++dispatch_time(
++++++++++++DISPATCH_TIME_NOW,
++++++++++++Int64(delay+*+Double(NSEC_PER_SEC))
++++++++),
++++++++dispatch_get_main_queue(),+closure)
}
struct+Foo+{
++++var+i+=+0
++++mutating+func+foo()+{
++++++++delay(0.5)+{
++++++++++++println("From+foo:+\(self.i)")+//+1
++++++++}
++++++++bar(2)
++++++++i%2B%2B
++++}
++++func+bar(d:Double)+{
++++++++delay(d)+{
++++++++++++println("from+bar:+\(self.i)")+//+0
++++++++}
++++}
}|6027|我会像这样测试它|6028|var+a+=+Foo()
a.foo()
a.bar(1)|6029|控制台显示：|6030|From+foo:+1+[after+half+a+second]
from+bar:+1+[after+1+second]
from+bar:+0+[after+2+seconds]|6031|那么，如何在1秒后的第二次调用bar，同时显示更早的self.i值呢？为什么foo的行为会有所不同？|6032|答案与以下事实有关:所有事情都发生在函数内部--包括匿名函数的定义。代码必须在某个时候运行。在此之前，匿名函数尚未定义。|6033|首先，让我们考虑一下a.bar(1)。这将导致bar运行并定义将捕获self的匿名函数。但是在我们调用foo和增量i之后就会发生这种情况。因此，此时捕获的self有一个递增的i。|ordered-list-item|6034|接下来，让我们考虑一下当foo调用bar时会发生什么。它在增量i之前就这样做了。因此，现在bar运行并定义了匿名函数，并捕获了i仍然设置为0的self。这个结果在两秒钟后到达控制台是不相关的；重要的是捕获发生的时间。|6035|最后，我们讨论了foo中的匿名函数这个令人惊讶的例子。显然，i%2B%2B在foo中的存在决定了一切的不同。为什么？当foo运行时，它定义了一个捕捉self的匿名函数。但是，这个self也是在foo本身中捕获的，目的是为了表示i%2B%2B+--实际上是self.i%2B%2B。因此，这个匿名函数也可以看到i%2B%2B在i%2B%2B上执行的更改，因为它们查看的是同一个self。
换句话说，我建议您已经碰到了匿名函数中定义的匿名函数的神秘边缘情况，该函数本身会变异self。(我不知道我是否认为这是一个bug；我将把它提交给dev论坛，看看他们怎么想。)|6036|entityMap^0|0|U|4|1D|4|1X|4|2G|4|0|0|0|0|0|0|0|0|0|F|3|Q|6|12|3|0|0|A|8|Y|4|1F|3|1L|1|25|4|2F|1|0|C|3|H|3|V|1|19|3|1R|1|1Z|4|0|8|3|U|3|Y|3|1J|3|1Y|4|2D|4|2K|3|31|3|3B|8|3Y|3|42|3|4N|4|5Z|4|0^^$0|@$1|2|3|4|5|6|7|1E|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1F|8|@$E|1G|F|1H|G|H]|$E|1I|F|1J|G|H]|$E|1K|F|1L|G|H]|$E|1M|F|1N|G|H]]|9|@]|A|$]]|$1|I|3|J|5|D|7|1O|8|@]|9|@]|A|$]]|$1|K|3|L|5|M|7|1P|8|@]|9|@]|A|$N|O]]|$1|P|3|Q|5|D|7|1Q|8|@]|9|@]|A|$]]|$1|R|3|S|5|M|7|1R|8|@]|9|@]|A|$N|O]]|$1|T|3|U|5|D|7|1S|8|@]|9|@]|A|$]]|$1|V|3|W|5|M|7|1T|8|@]|9|@]|A|$N|O]]|$1|X|3|Y|5|D|7|1U|8|@]|9|@]|A|$]]|$1|Z|3|10|5|M|7|1V|8|@]|9|@]|A|$N|O]]|$1|11|3|12|5|D|7|1W|8|@$E|1X|F|1Y|G|H]|$E|1Z|F|20|G|H]|$E|21|F|22|G|H]]|9|@]|A|$]]|$1|13|3|14|5|D|7|23|8|@]|9|@]|A|$]]|$1|15|3|16|5|17|7|24|8|@$E|25|F|26|G|H]|$E|27|F|28|G|H]|$E|29|F|2A|G|H]|$E|2B|F|2C|G|H]|$E|2D|F|2E|G|H]|$E|2F|F|2G|G|H]]|9|@]|A|$]]|$1|18|3|19|5|17|7|2H|8|@$E|2I|F|2J|G|H]|$E|2K|F|2L|G|H]|$E|2M|F|2N|G|H]|$E|2O|F|2P|G|H]|$E|2Q|F|2R|G|H]|$E|2S|F|2T|G|H]]|9|@]|A|$]]|$1|1A|3|1B|5|17|7|2U|8|@$E|2V|F|2W|G|H]|$E|2X|F|2Y|G|H]|$E|2Z|F|30|G|H]|$E|31|F|32|G|H]|$E|33|F|34|G|H]|$E|35|F|36|G|H]|$E|37|F|38|G|H]|$E|39|F|3A|G|H]|$E|3B|F|3C|G|H]|$E|3D|F|3E|G|H]|$E|3F|F|3G|G|H]|$E|3H|F|3I|G|H]|$E|3J|F|3K|G|H]]|9|@]|A|$]]|$1|1C|3|-4|5|D|7|3L|8|@]|9|@]|A|$]]]|1D|$]]

<blockquote>
I'm wondering what is the best way here to avoid capturing a copy of an ivar.
</blockquote>
That is a misconception. You cannot &quot;capture an ivar&quot; in this way. What you are capturing is <code>self</code>! That is exactly why Swift forces you to say <code>self</code>, so that you understand this fact. Thus, it makes a difference what kind of thing <code>self</code> is. And that is why it matters whether <code>self</code> is a struct or a class. The class instance is mutable in place; the struct instance is not, so a copy is taken at the time of capture and that copy persists independently.
However, you can capture a simple Int (i.e. not an ivar), and when you do, you get the result you expect:
<pre><code>var i = 0
struct Foo {
 func delayedPrint() {
 dispatch_async(dispatch_get_main_queue(), {
 println(i) // 1
 })
 }
 func foo() {
 delayedPrint()
 i++
 }
}
</code></pre>
<hr />
Now let's talk about the second puzzle that you pose. Here's a rewrite, to clarify what the puzzle is:
<pre><code>func delay(delay:Double, closure:()-&gt;()) {
 dispatch_after(
 dispatch_time(
 DISPATCH_TIME_NOW,
 Int64(delay * Double(NSEC_PER_SEC))
 ),
 dispatch_get_main_queue(), closure)
}
struct Foo {
 var i = 0
 mutating func foo() {
 delay(0.5) {
 println(&quot;From foo: \(self.i)&quot;) // 1
 }
 bar(2)
 i++
 }
 func bar(d:Double) {
 delay(d) {
 println(&quot;from bar: \(self.i)&quot;) // 0
 }
 }
}
</code></pre>
I'll test it like this:
<pre><code>var a = Foo()
a.foo()
a.bar(1)
</code></pre>
The console shows:
<pre><code>From foo: 1 [after half a second]
from bar: 1 [after 1 second]
from bar: 0 [after 2 seconds]
</code></pre>
So how can <code>bar</code> be called the second time 1 second later, yet show a value of <code>self.i</code> that is earlier? And why does <code>foo</code> behave differently?
The answer has to do with the fact that everything is happening inside functions - including the definitions of the anonymous functions. The code has to run at some point. Until then, the anonymous function is not defined.
<ol>
<li>First let's consider <code>a.bar(1)</code>. This causes bar to run and to define the anonymous function which will capture <code>self</code>. But this happens after we have called <code>foo</code> and incremented <code>i</code>. Thus, the <code>self</code> captured at this time has an incremented <code>i</code>.
</li>
<li>Next let's consider what happens when <code>foo</code> calls <code>bar</code>. It does this before incrementing <code>i</code>. So now <code>bar</code> runs and the anonymous function is defined, and captures <code>self</code> with <code>i</code> still set at 0. The fact that this result arrives into the console two seconds later is irrelevant; what is important is when the capture took place.
</li>
<li>Finally we come to the surprising case of the anonymous function inside <code>foo</code>. Clearly, the presence of the <code>i++</code> inside <code>foo</code> make all the difference. Why? Well, when <code>foo</code> runs, it defines an anonymous function that captures <code>self</code>. But this <code>self</code> has also been captured inside <code>foo</code> itself for the purposes of saying <code>i++</code> — which is really <code>self.i++</code>. Thus, the change on <code>self</code> performed by <code>i++</code> is seen by this anonymous function as well, because they are looking at the same <code>self</code>.
In other words, I'm suggesting that you have hit the Mysterious Edge Case of the anonymous function defined within a function that itself mutates <code>self</code>. (I don't know if I think this a bug or not; I'm going to submit it to dev forum and see what they think.)
</li>
</ol>

<pre><code>struct Foo {

 var i = 0 { didSet { println("Current i: \(i)") } }

 func delayedPrint() {
 dispatch_async(dispatch_get_main_queue(), { _ in
 println("Closure i: \(self.i)")
 })
 }

 mutating func foo() {
 delayedPrint()
 i++
 }
}
</code></pre>

<hr>

Now the output of

<pre><code>var a = Foo()
a.foo()
</code></pre>

is

<pre><code>Current i: 1
Closure i: 0 // I want current value here.
</code></pre>

I'm wondering what is the best way here to avoid capturing a copy of an ivar.

<hr>

EDIT 1

Yes, moving to class was the first and only thing I've thought of but... this one fooled me to think it can be done somehow with struct... Why it works?

<pre><code>mutating func foo() {
 delayedPrint()
 dispatch_async(dispatch_get_main_queue(), { _ in
 println("From foo: \(self.i)")
 })
 delayedPrint()
 i++
}
</code></pre>

Output:

<pre><code>Current i: 1
Closure i: 0
From foo: 1
Closure i: 0
</code></pre>

<hr>

Best way to avoid capturing a copy of the value in closure

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

struct Foo {    var i = 0 { didSet { println("Current i: \(i)") } }    func delayedPrint() {        dispatch_async(dispatch_get_main_queue(), { _ in            ...

问避免在闭包中捕获值副本的最佳方法
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问避免在闭包中捕获值副本的最佳方法EN