IOS block

准备走ios开发之一块，但是感觉C/C++的底子还是不够，既然之前学过，趁着刚刚学oc，还能做个对比什么的。

参考：

http://www.ithao123.cn/content-5613988.html
http://www.cnblogs.com/wustlj/archive/2013/08/12/3252152.html
http://www.dreamingwish.com/article/block%E4%BB%8B%E7%BB%8D%EF%BC%88%E5%9B%9B%EF%BC%89%E6%8F%AD%E5%BC%80%E7%A5%9E%E7%A7%98%E9%9D%A2%E7%BA%B1%EF%BC%88%E4%B8%8B%EF%BC%89.html
http://www.cnblogs.com/biosli/archive/2013/05/29/iOS_Objective-C_Block.html
http://www.zhihu.com/question/30779258
http://blog.csdn.net/hherima/article/details/38586101?utm_source=tuicool&utm_medium=referral

block 被称为自动截获变量匿名函数

1。内存方面
普通声明的block是存在栈中的，通过copy得来的会存储在堆中。

int main(int argc, const char *argv[]){
   @autoreleasepool{
      int j = 1;
      __block int i = 1024;
      void (^block)(void) = ^{
         printf("%d%d\n", i, j);
      }
      block();
      void (^inheapblock)(void) = Block_copy(block);
      inheapblock();
      i++;
      j++;
      block();
      inheapblock();
      block();
      printf("%d %d\n", i, j);
   }
}

结果会是
1024 1
1024 1
1025 1
1025 1
1025 2

• 首先，我们在栈上创建了变量ij，并赋予初始值，然后创建一个block变量名为block，但未赋值。
• 然后我们初始化这个block，赋值为一个只有一句printf的block，值得注意的是你定义完block之后，其实是创建了一个函数，在创建结构体的时候把函数的指针一起传给了block，所以之后可以拿出来调用。，其引用到的常规变量会进行如下操作：
• 没有__block标记的变量，其值会被复制一份到block私有内存区 有__block标记的变量，其地址会被记录在block私有内存区 然后调用block，打印1024, 1很好理解.
• 接下来复制block到堆，名曰inheapblock(下面称为ihb），调用，打印1024, 1也很好理解.

• 接下来我们为ij增值，使其变为1025和2，此时再调用block或者ihb，会发现结果为1025, 1，这是因为变量j早已在创建原始的block时，被赋值进block的私有内存区，后续对i的操作并非操作的私有内存区的复制品，当调用block或者ihb时，其打印使用的是私有内存区的复制品，故而打印结果依旧为1；而变量j的修改会实时生效，因为block记录的是它的地址，通过地址来访问其值，使得外部对j的修改在block中得以生效.

  我们再来看下源码剖析
  http://llvm.org/svn/llvm-project/compiler-rt/trunk/lib/BlocksRuntime/runtime.c
  http://llvm.org/svn/llvm-project/compiler-rt/trunk/lib/BlocksRuntime/Block_private.h

block定义无非两个东西

struct Block_descriptor {
    unsigned long int reserved;
    unsigned long int size;
    void (*copy)(void *dst, void *src);
    void (*dispose)(void *);
};


struct Block_layout {
    void *isa;
    int flags;
    int reserved; 
    void (*invoke)(void *, ...);
    struct Block_descriptor *descriptor;
    /* Imported variables. */
};

在Objective-C中，类都是继承NSObject的，NSObject里面都会有个isa，是一个objc_class指针。
我们可以通过clang-rewrite 去看下，我们的block到底怎样实现的。

^int(){printf("val"); return 111;};

这个block会被转化为

struct __block_impl {
  void *isa;
  int Flags;
  int Reserved;
  void *FuncPtr;
};

struct __testBlock_block_impl_0 {
  struct __block_impl impl;
  struct __testBlock_block_desc_0* Desc;
  __testBlock_block_impl_0(void *fp, struct __testBlock_block_desc_0 *desc, int flags=0) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

__testBlock_block_impl_0是block结构，他的第一个属性也是一个结构__block_impl，而第一个参数也是一个isa的指针。我们可以看到isa指针刚刚的值是&_NSConcreteStackBlock;，在栈上创建的。
在运行时，NSObject和block的isa指针都是指向在对象一个4字节。
isa指针一共有以下几种
BLOCK_EXPORT void * _NSConcreteStackBlock[32];
BLOCK_EXPORT void * _NSConcreteMallocBlock[32];
BLOCK_EXPORT void * _NSConcreteAutoBlock[32];
BLOCK_EXPORT void * _NSConcreteFinalizingBlock[32];
BLOCK_EXPORT void * _NSConcreteGlobalBlock[32];
BLOCK_EXPORT void * _NSConcreteWeakBlockVariable[32];

1. – 如果是定义在函数外面的block是global的，另外如果函数内部的block但是，没有捕获任何自动变量，那么它也是全局的。比如下面这样的代码：

   void (^block) (void) = ^{ printf("Hello world\n"); }; int
main(int argc, const char * argv[]) { ...... } clang
   -rewrite 之后会发现是是 isa = _NSConcreteGlobalBlock；
   copy 对 Global无效
   在非ARC下执行如下代码：

//非MyBlock block = func();
NSLog(@"%d", block());
NSLog(@"%@", [block class]);

MyBlock block2 = [block copy];
//Copy操作对__NSGlobalBlock__类型无效
NSLog(@"%d", block == block2);

123
__NSGlobalBlock__
1
可以看到，copy后的Block和原来是同一个对象的。

而对于引用了外部变量的Block，如果没有对他进行copy，他的作用域只会在声明他的函数栈内（类型是NSStackBlock），

1. 一种情况在非ARC下是无法编译的：

 typedef int(^blk_t)(int); 
 blk_t func(int rate){
        return ^(int count){return rate*count;} }

而对于引用了外部变量的Block，如果没有对他进行copy，他的作用域只会在声明他的函数栈内（类型是NSStackBlock），如果想在非ARC下直接返回此类Block，Xcode会提示编译错误的

这是因为：block捕获了栈上的rate自动变量，此时rate已经变成了一个结构体，而block中拥有这个结构体的指针。即如果返回block的话就是返回局部变量的指针。而这一点恰是编译器已经断定了。在ARC下没有这个问题，因为ARC会自动加入copy操作（类型是NSMallocBlock）

3.有时候我们需要调用block 的copy函数，将block拷贝到堆上。看下面的代码：

-(id) getBlockArray{
    int val =10;
    return [[NSArray alloc]initWithObjects:
        ^{NSLog(@"blk0:%d",val);},
        ^{NSLog(@"blk1:%d",val);},nil];
}

id obj = getBlockArray();
typedef void (^blk_t)(void);
blk_t blk = (blk_t)[obj objectAtIndex:0];
blk();

这段代码在最后一行blk()会异常，因为数组中的block是栈上的。因为val是栈上的。解决办法就是调用copy方法。

4.不管block配置在何处，用copy方法复制都不会引起任何问题。在ARC环境下，如果不确定是否要copy block尽管copy即可。ARC会打扫战场。
注意：在栈上调用copy那么复制到堆上，在全局block调用copy什么也不做，在堆上调用block 引用计数增加

但是可以改变全局变量、静态变量、全局静态变量。 其实这两个特点不难理解：第一、为何不让修改变量：这个是编译器决定的。理论上当然可以修改变量了，只不过block捕获的是自动变量的副本，名字一样。为了不给开发者迷惑，干脆不让赋值。道理有点像：函数参数，要用指针，不然传递的是副本。 第二、可以修改静态变量的值。静态变量属于类的，不是某一个变量。所以block内部不用调用cself指针。所以block可以调用。 解决block不能保存值这一问题的另外一个办法是使用__block修饰符。

http://www.cnblogs.com/biosli/archive/2013/05/29/iOS_Objective-C_Block.html中有介绍关于copy的问题