IOS数据类型及其所有修饰符的使用规则

IOS数据类型大致可分为以下几种：
1.基本数据类型：Int BOOL Float等一般用assign修复修饰
2.普通引用类型：NSObject以及我们自定义的普通对象用strong修饰
3.特殊引用类型：NSString，NSArray，NSDictionary，NSSet等一帮用copy修饰
4.UIView及其子类类型：修饰符用weak修饰
5.block也是一种类型它的修饰符也是copy

Object-C作为底层是C的一门特殊的C语言的它的内存分配如下：

  栈区(stack)： 存放函数的参数值、局部变量的值等，由编译器自动分配释放，通常在函数执行结束后就释放了 ，其操作方式类似数据结构中的栈。栈内存分配运算内置于处理器的指令集，效率很高，但是分配的内存容量有限，比如iOS中栈区的大小是2M。

堆区(heap)：就是通过new、malloc、realloc分配的内存块， 它们的释放编译器不去管，由我们的应用程序去释放。如果应用程序没有释放掉，操作系统会自动回收 。分配方式类似于链表。

静态区： 全局变量和静态变量的存储是放在一块的 ，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束后，由系统释放。

常量区：常量存储在这里，不允许修改的。

代码区：存放函数体的二进制代码。

栈区在什么时候释放内存呢？我们通过下面的一个例子来说明下：

• (void)print {
  int i = 30;
  int j = 60;
  NSLog(@”i+j = %d”, (i+j));
  }

在上面的代码中当程序执行到 } 的时候，变量i和j的作用域已经结束了，编译器就会自动释放掉i和j所占的内存，所以理解好作用域就理解了栈区的内存分配。

栈区和堆区的区别主要为以下几点：

对于栈来说，内存管理由编译器自动分配释放；对于堆来说，释放工作由程序员控制。

栈的空间大小比堆小许多。

栈是机器系统提供的数据结构，计算机会在底层对栈提供支持，所以分配效率比堆高。

栈中存储的变量出了作用域就无效了，而堆由于是由程序员进行控制释放的，变量的生命周期可以延长。

我们在定义一个变量的时候都会使用@property开头，有时也会用下面这俩@synthesize 和 @dynamic他们分别代表什么意思又有什么作用呢？

1.@property = ivar + getter + setter;

从上面可以看出 @property的本质就是ivar(实例变量)加存取方法(getter + setter) 。在我们属性定义完成后，编译器会自动生成该属性的getter和setter方法，这个过程就叫做自动合成。除了生成getter与setter方法，编译器还要自动向类中添加适当类型的实例变量，并且在属性名前面加下划线，以此做实例变量的名字。

2.@synthesize

   @synthesize 的作用就是如果你没有手动实现getter与setter方法，那么编译器就会自动为你加上这两个方法。

3.@dynamic

    @dynamic的作用就是告诉编译器，getter与setter方法由用户自己实现，不自动生成。当然对于readonly的属性只需要提供getter即可。

如果都没有写@synthesize和@dynamic，那么默认的就是@synthesize var = _var;

我们目前如果没有特殊需要几乎都是使用@property.

现在咱们来介绍block在使用过程中使用的注意点：

1.首先声明block属性的时候为什么用copy呢？

 在说明为什么要用copy前，先思考下block是存储在栈区还是堆区呢？其实block有3种类型：
全局块(_NSConcreteGlobalBlock)

栈块(_NSConcreteStackBlock)

堆块(_NSConcreteMallocBlock)

全局块存储在静态区（也叫全局区），相当于Objective-C中的单例；

栈块存储在栈区，超出作用域则马上被销毁。

堆块存储在堆区中，是一个带引用计数的对象，需要自行管理其内存。

2.怎么判断一个block所在的存储位置呢？

block不访问外界变量（包括栈中和堆中的变量）

block既不在栈中也不在堆中，此时就为全局块，ARC和MRC下都是如此。

block访问外界变量

 MRC环境下：访问外界变量的block默认存储在栈区。

 ARC环境下：访问外界变量的block默认存放在堆中，实际上是先放在栈区，在ARC情况下自动又拷贝到堆区，自动释放。

使用copy修饰符的作用就是将block从栈区拷贝到堆区，为什么要这么做呢？我们复制到堆区的主要目的就是保存block的状态，延长其生命周期。 因为block如果在栈上的话，其所属的变量作用域结束，该block就被释放掉，block中的__block变量也同时被释放掉。为了解决栈块在其变量作用域结束之后被释放掉的问题，我们就需要把block复制到堆中。

不同类型的block使用copy方法的效果也不一样，如下所示：

我们先看下例子1：

  - (void)testMethod {
int anInteger = 42;

void (^testBlock)(void) = ^{
    NSLog(@"Integer is : %i", anInteger);
};

anInteger = 50;

testBlock();

}

运行后输出的结果如下：

Integer is : 42

为什么不是50呢？这个问题稍后做解释。我们在看加入__block的情况，例子2如下：

• (void)testMethod {
  __block int anInteger = 42;

  void (^testBlock)(void) = ^{
  NSLog(@”Integer is : %i”, anInteger);
  };

  anInteger = 50;

  testBlock();
  }

运行后输出的结果如下：

Integer is : 50

两次运行结果不一样，中间发生了什么呢？我们接下来来具体分析下。

在例子1中，block会把anInteger变量复制为自己私有的const变量， 也就是说block会捕获栈上的变量(或指针)，将其复制为自己私有的const变量 。在例子1中，在进行anInteger = 50的操作的时候，block已经将其复制为自己的私有变量，所以这里的修改对block里面的anInteger不会造成任何影响。

在例子2中，anInteger是一个局部变量，存储在栈区的。 给anInteger加入__block修饰符所起到的作用就是只要观察到该变量被block所持有，就将该变量在栈中的内存地址放到堆中，此时不管block外部还是内部anInterger的内存地址都是一样的，进而不管在block外部还是内部都可以修改anInterger变量的值 ，所以anInteger = 50之后，在block输出的值就是50了。可以通过一个图简单来描述一下：

3.block中循环引用的问题？使用系统的block api是否也考虑循环引用的问题？weak与strong之间的区别？

在使用block的时候，我们要特别注意循环引用的问题，先来看一个循环引用的例子：

@interface XYZBlockKeeper : NSObject

@property (nonatomic, copy) void (^block)(void);

@end

@implementation XYZBlockKeeper

• (void)configureBlock {
  self.block = ^{
  [self doSomething];
  };
  }

@end

在上面的代码中我们声明了一个block属性，所以self对block有一个强引用。而在block内部又对self进行了一次强引用，这样就形成了一个封闭的环，也就是我们经常说的强引用循环。引用关系如图：

在这种情况下，由于其相互引用，内存不能够进行释放，就造成了内存泄漏的问题。怎么解决循环引用的问题呢？我们经常通过声明一个weakSelf来解决循环引用的问题，更改后的代码如下：

• (void)configureBlock {
  __weak typeof(self) weakSelf = self;
  self.block = ^{
  [weakSelf doSomething];
  };
  }

  加入weakSelf之后，block对self就由强引用关系变成了弱引用关系，这样在属性所指的对象遭到摧毁时，属性值也会被清空，就打破了block捕获的作用域带来的循环引用。这跟设置self.block = nil是同样的道理。

  在使用系统提供的block api需要考虑循环引用的问题吗？比如：

[UIView animateWithDuration:0.5 animations:^{
[self doSomething];
}];

 在这种情况下是不需要考虑循环引用的，因为这里只有block对self进行了一次强引用，属于单向的强引用，没有形成循环引用。

weak与strong有什么区别呢？先看一段代码：

• (void)configureBlock {
  __weak typeof(self) weakSelf = self;
  self.block = ^{
  [weakSelf doSomething]; // weakSelf != nil
  // preemption(抢占) weakSelf turned nil
  [weakSelf doAnotherThing];
  };
  }

  这段代码看起来很正常呀， 但是在并发执行的时候，block的执行是可以抢占的，而且对weakSelf指针的调用时序不同可以导致不同的结果 ，比如在一个特定的时序下weakSelf可能会变成nil，这个时候在执行doAnotherThing就会造成程序的崩溃。为了避免出现这样的问题，采用__strong的方式来进行避免，更改后的代码如下：

• (void)configureBlock {
  __weak typeof(self) weakSelf = self;
  self.block = ^{
  __strong typeof(weakSelf) strongSelf = weakSelf;
  [strongSelf doSomething]; // strongSelf != nil
  // 在抢占的时候，strongSelf还是非nil的。
  [strongSelf doAnotherThing];
  };
  }

  从代码中可以看出 加入__strong所起的作用就是在抢占的时候strongSelf还是非nil的，避免出现nil的情况 。

总结：

在block不是作为一个property的时候，可以在block里面直接使用self，比如UIView的animation动画block。

当block被声明为一个property的时候，需要在block里面使用weakSelf，来解决循环引用的问题。

当和并发执行相关的时候，当涉及异步的服务的时候，block可以在之后被执行，并且不会发生关于self是否存在的问题。