Blocks and Variables
http://stackoverflow.com/questions/16149653/what-is-the-role-of-the-copy-in-the-arc
This article describes the interaction between blocks and variables, including memory management.
这篇文章描写叙述了 blocks 与变量间的交互作用。同一时候也包含内存管理。
Types of Variable
Within the block object’s body of code, variables may be treated in five different ways.
在 block 对象体中插入的代码。变量能够分为5种。
You can reference three standard types of variable, just as you would from a function:
你能够引用 3 种标准类型的变量，就像你在普通方法中使用的那样子：
- Global variables, including static locals 全局变量，包含 static 修饰过的静态变量
- Global functions (which aren’t technically variables) 全局方法（技术上来说不能被称作变量）
- Local variables and parameters from an enclosing scope 局部变量和从上下文中带进来的參数
Blocks also support two other types of variable:
Blocks 也支持另外两种类型的变量：
- At function level are
__blockvariables. These are mutable within the block (and the enclosing scope) and are preserved if any referencing block is copied to the heap. 函数级别上的 __block
修饰的对象。它在block里面是能够改动的。假设这个 block 被 copy 到了栈区。这个对象就会被强引用。 constimports. const引入的。
Finally, within a method implementation, blocks may reference Objective-C instance variables—see “Object
and Block Variables.”
终于。在一个方法的实现其中。blocks 或许会强引用 Objective-C 实例变量。请參考 “Object
and Block Variables.”
The following rules apply to variables used within a block:
下面规则适用于在 block 中使用的变量：
- Global variables are accessible, including static variables that exist within the enclosing lexical scope. 能够接收全局变量。包含存在于上下文中的静态变量。
- Parameters passed to the block are accessible (just like parameters to a function). 传递到 block 中的变量（就像函数传递參数一样）
- Stack (non-static) variables local to the enclosing lexical scope are captured as
constvariables. 相对于 block 块的非静态堆区对象被识别为 const 对象。Their values are taken at the point of the block expression within the program. In nested blocks, the value is captured from the nearest enclosing scope. 他们的值会以指针的形式传递到 block 中。
- Variables local to the enclosing lexical scope declared with the
__blockstorage modifier are provided by reference and so are mutable. __block 修饰的对象同意在 block 中进行改动。并会被 block 强引用。Any changes are reflected in the enclosing lexical scope, including any other blocks defined within the same enclosing lexical scope. These are discussed in more detail in “The
__block Storage Type.” - Local variables declared within the lexical scope of the block, which behave exactly like local variables in a function. 在 block 块中实例化的对象，与在函数中实例化的对象基本一致。
Each invocation of the block provides a new copy of that variable. These variables can in turn be used as
constor by-reference variables in blocks enclosed within the block. 每一次调用这个
block 都会提供一个变量的 copy。对应的。这些对象能够被当做 const 或者是强引用的对象使用。
The following example illustrates the use of local non-static variables:
下面样例描写叙述了怎样使用一个本地非 static 的变量：
int x = 123; |
void (^printXAndY)(int) = ^(int y) {
|
printf("%d %d\n", x, y);
|
}; |
printXAndY(456); // prints: 123 456 |
As noted, trying to assign a new value to x within the block would result in an error:
正如提到的那样，给 x 在 block 中直接赋值会引发错误：
int x = 123; |
void (^printXAndY)(int) = ^(int y) {
|
x = x + y; // error |
printf("%d %d\n", x, y);
|
}; |
To allow a variable to be changed within a block, you use the __block storage type modifier—see “The
__block Storage Type.”
为了同意一个变量在 block 中能够被改动。你须要使用 __block 存储的类型，查看 “The
__block Storage Type.”
The __block Storage Type
You can specify that an imported variable be mutable—that is, read-write— by applying the __block storage type modifier. __block storage is similar to, but mutually exclusive of, the register, auto,
and static storage types for local variables.
你能够指定引入的对象能够被改动。那就是，可读可写。通过给这个变量修饰 __block 存储改动类型。__block 存储与 register ，auto。static 存储方式相互排斥（对于一个别修饰的变量）。
__block variables live in storage that is shared between the lexical scope of the variable and all blocks and block copies declared or created within the variable’s lexical scope. Thus, the storage will survive the destruction
of the stack frame if any copies of the blocks declared within the frame survive beyond the end of the frame (for example, by being enqueued somewhere for later execution). Multiple blocks in a given lexical scope can simultaneously use a shared variable.
__block 变量在一个容器中存活，能够被变量的上下文共享，能够被全部 block 共享。能够被 copy 修饰过的 block 共享，以及在 block 块中创建的对象共享。也就是说。假设有不论什么 copy 出来的 block 用了这个变量。它会一直存活于堆区其中。
As an optimization, block storage starts out on the stack—just like blocks themselves do. If the block is copied using Block_copy (or in Objective-C when the block is sent a copy), variables are copied to
the heap. Thus, the address of a __block variable can change over time.
作为一个优化，block 存储開始与堆区，就像 blocks 他们自己做的那样子。假设这个 block 被 copy 了（或者在 OC 其中 block 接收到了 copy 消息）。
变量就会被拷贝到栈区去。
也就是说，这个变量能够一直被改动了。
There are two further restrictions on __block variables: they cannot be variable length arrays, and cannot be structures that contain C99 variable-length arrays.
对于 __block 变量有着两点限制：他们不能用于可变长度的数组，也不能包含C99中可变长度数组的结构体。
The following example illustrates use of a __block variable:
下面样例描写叙述了怎么使用 __block 变量：
__block int x = 123; // x lives in block storage |
void (^printXAndY)(int) = ^(int y) {
|
x = x + y; |
printf("%d %d\n", x, y);
|
}; |
printXAndY(456); // prints: 579 456 |
// x is now 579 |
The following example shows the interaction of blocks with several types of variables:
下面样例显示了 blocks 怎样与不同类型的变量交互：
extern NSInteger CounterGlobal; |
static NSInteger CounterStatic; |
{
|
NSInteger localCounter = 42; |
__block char localCharacter; |
void (^aBlock)(void) = ^(void) {
|
++CounterGlobal; |
++CounterStatic; |
CounterGlobal = localCounter; // localCounter fixed at block creation |
localCharacter = ‘a‘; // sets localCharacter in enclosing scope |
}; |
++localCounter; // unseen by the block |
localCharacter = ‘b‘; |
aBlock(); // execute the block |
// localCharacter now ‘a‘ |
} |
Object and Block Variables
Blocks provide support for Objective-C and C++ objects, and other blocks, as variables.
Blocks 对 OC 以及 C++ 对象提供支持，以及其它种类的 block 最为变量。
Objective-C Objects
When a block is copied, it creates strong references to object variables used within the block. If you use a block within the implementation of a method:
当一个 block copy了，它会对每个出如今 block 中的变量创建一个强引用。
假设你在一个方法的实现中使用了 block：
- If you access an instance variable by reference, a strong reference is made to
self; 假设你引用了一个实例变量。这会创建一个强引用指向 self - If you access an instance variable by value, a strong reference is made to the variable. 假设你引用了一个实例变量的值，这回创建一个对这个变量的强引用
The following examples illustrate the two different situations:
下面样例描写叙述了两种不同的情形：
dispatch_async(queue, ^{
|
// instanceVariable is used by reference, a strong reference is made to self |
doSomethingWithObject(instanceVariable); |
}); |
id localVariable = instanceVariable; |
dispatch_async(queue, ^{
|
/* |
localVariable is used by value, a strong reference is made to localVariable |
(and not to self). |
*/ |
doSomethingWithObject(localVariable); |
}); |
To override this behavior for a particular object variable, you can mark it with the __block storage type modifier.
为了重写这样的表现形式，你能够给变量标记上 __block 存储方式。
Blocks
When you copy a block, any references to other blocks from within that block are copied if necessary—an entire tree may be copied (from the top). If you have block variables and you reference a block from within the block, that block
will be copied.
当你 copy 一个 block，不管参考其他 block 会是 copy。
将规划建设一个树状结构。假设你有 block 变数，和在里面 block 引用在此 block，那个 block 会是copy。