retain和copy还有assign的区别

1. 接触过C，那么假设你用malloc分配了一块内存，并且把它的地址赋值给了指针a，后来你希望指针b也共享这块内存，于是你又把a赋值给 （assign）了b。此时a和b指向同一块内存，请问当a不再需要这块内存，能否直接释放它？答案是否定的，因为a并不知道b是否还在使用这块内存，如 果a释放了，那么b在使用这块内存的时候会引起程序crash掉。
2.
了解到1中assign的问题，那么如何解决？最简单的一个方法就是使用引用计数（reference
counting），还是上面的那个例子，我们给那块内存设一个引用计数，当内存被分配并且赋值给a时，引用计数是1。当把a赋值给b时引用计数增加到
2。这时如果a不再使用这块内存，它只需要把引用计数减1，表明自己不再拥有这块内存。b不再使用这块内存时也把引用计数减1。当引用计数变为0的时候，
代表该内存不再被任何指针所引用，系统可以把它直接释放掉。
3.
上面两点其实就是assign和retain的区别，assign就是直接赋值，从而可能引起1中的问题，当数据为int,
float等原生类型时，可以使用assign。retain就如2中所述，使用了引用计数，retain引起引用计数加1,
release引起引用计数减1，当引用计数为0时，dealloc函数被调用，内存被回收。
4. copy是在你不希望a和b共享一块内存时会使用到。a和b各自有自己的内存。就是说修改了b的内容不会影响到a

5. retain是a和b共享一块内存，b如果后面发生变化那么a也会同样发生改变，所以特别是nsstring类型的变量如果不想这样的话就最好声明为copy类型的。

例子程序如下：
#import <UIKit/UIKit.h>

@interface KidsAppDelegate : UIResponder <UIApplicationDelegate>
{
    NSString* strRetain;
    NSString* strCopy;
}

@property (strong, nonatomic) UIWindow *window;
@property (retain, nonatomic) NSString* strRetain;
@property (copy, nonatomic)   NSString* strCopy;
@end

#import "KidsAppDelegate.h"

@implementation KidsAppDelegate

@synthesize strRetain =_strRetain;
@synthesize strCopy = _strCopy;

- (void)dealloc
{
    
    [_strRetain release];
    [_strCopy release];
    [_window release];
    [super dealloc];
}

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
    NSMutableString * string = [NSMutableString stringWithString:@"hello"];
    self.strCopy = string;
    self.strRetain = string;
    [string appendString:@" world!"];      
    
    NSLog(@"%@",string); ／／hello world！
    NSLog(@"%@ %@",self.strCopy, self.strRetain);／／hello hello world！
    return YES;
}
6. atomic和nonatomic用来决定编译器生成的getter和setter是否为原子操作。在多线程环境下，原子操作是必要的，否则有可能引起错误的结果。加了atomic，setter函数会变成下面这样：
{lock}
if (property != newValue) { 
    [property release]; 
    property = [newValue retain]; 
}
{unlock}

7. assign: 默认属性，简单赋值，不更改索引计数 对基础数据类型 （例如NSInteger，CGFloat）和C数据类型（int, float, double, char, 等）       适用简单数据类型

使用@dynamic关键字是告诉编译器由我们自己来实现访问方法。如果使用的是@synthesize，那么这个工作编译器就会帮你实现了。

readonly此标记说明属性是只读的，默认的标记是读写，如果你指定了只读，在@implementation中只需要一个读取器。或者如果你使用@synthesize关键字，也是有读取器方法被解析。而且如果你试图使用点操作符为属性赋值，你将得到一个编译错误。

readwrite此标记说明属性会被当成读写的，这也是默认属性。设置器和读取器都需要在@implementation中实现。如果使用@synthesize关键字，读取器和设置器都会被解析。

nonatomic：非原子性访问，对属性赋值的时候不加锁，多线程并发访问会提高性能。如果不加此属性，则默认是两个访问方法都为原子型事务访问。

atomic和nonatomic用来决定编译器生成的getter和setter是否为原子操作。

atomic
                设置成员变量的@property属性时，默认为atomic，提供多线程安全。
                在多线程环境下，原子操作是必要的，否则有可能引起错误的结果。加了atomic，setter函数会变成下面这样：
                        {lock}
                                if (property != newValue) { 
                                        [property release]; 
                                        property = [newValue retain]; 
                                }
                        {unlock}
        nonatomic
        禁止多线程，变量保护，提高性能。
       
atomic是Objc使用的一种线程保护技术，基本上来讲，是防止在写未完成的时候被另外一个线程读取，造成数据错误。而这种机制是耗费系统资源的，所
以在iPhone这种小型设备上，如果没有使用多线程间的通讯编程，那么nonatomic是一个非常好的选择。
       
指出访问器不是原子操作，而默认地，访问器是原子操作。这也就是说，在多线程环境下，解析的访问器提供一个对属性的安全访问，从获取器得到的返回值或者通
过设置器设置的值可以一次完成，即便是别的线程也正在对其进行访问。如果你不指定 nonatomic
，在自己管理内存的环境中，解析的访问器保留并自动释放返回的值，如果指定了 nonatomic ，那么访问器只是简单地返回这个值。

assign: 简单赋值，不更改索引计数
对基础数据类型 （例如NSInteger，CGFloat）和C数据类型（int, float, double, char, 等）       适用简单数据类型

此
标记说明设置器直接进行赋值，这也是默认值。在使用垃圾收集的应用程序中，如果你要一个属性使用assign，且这个类符合NSCopying协    
        议，你就要明确指出这个标记，而不是简单地使用默认值，否则的话，你将得到一个编译警告。这再次向编译器说明你确实需要赋值，即使它是
          可拷贝的。

copy:建立一个索引计数为1的对象，然后释放旧对象                对NSString    所以每次使用copy时也时会释放掉之前的对象的。

对NSString 它指出，在赋值时使用传入值的一份拷贝。拷贝工作由copy方法执行，此属性只对那些实行了NSCopying协议的对象类型有效。更深入的讨论，请参考“复制”部分。

比如，NSDicionary的key，通常是一个NSString，如果这个NSString是NSMutableString，那么这个key 就可能发生变化，NSDicionay就可能无法找到这个key对应的value，造成memory leak，所以NSDictioary的key的属性方法，使用的就是copy。

will call release on the previous value before copying the new value, so the only memory management you have to worry about is releasing in the dealloc method, which you're doing.

使用copy的变量在调用copy时会释放掉之前的对象然后拷贝新对象，引用计数也不会加一和retain不同。所以唯一需要你自己手动注意处理的地方就是在dealloc方法中调用这个变量的release方法。

retain:释放旧的对象，将旧对象的值赋予输入对象，再提高输入对象的索引计数为1
对其他NSObject和其子类

对参数进行release旧值，再retain新值
        指定retain会在赋值时唤醒传入值的retain消息。此属性只能用于Objective-C对象类型，而不能用于Core
Foundation对象。(原因很明显，retain会增加对象的引用计数，而基本数据类型或者Core
Foundation对象都没有引用计数——译者注)。
        注意: 把对象添加到数组中时，引用计数将增加对象的引用次数+1。

retain的实际语法为：
- (void)setName:(NSString *)newName { 
    if (name != newName) { 
       [name release]; 
       name = [newName retain]; 
       // name’s retain count has been bumped up by 1 
    } 
}

copy与retain：

Copy其实是建立了一个相同的对象，而retain不是：copy是指针不同内容相同，retain是指针相同当然内容也相同
比如一个NSString对象，地址为0×1111，内容为@”STR”
Copy到另外一个NSString之后，地址为0×2222，内容相同，新的对象retain为1，旧有对象没有变化
retain到另外一个NSString之后，地址相同（建立一个指针，指针拷贝），内容当然相同，这个对象的retain值+1
也就是说，retain是指针拷贝，copy是内容拷贝。哇，比想象的简单多了…

retain的set方法应该是浅复制，copy的set方法应该是深复制了

copy另一个用法：
copy是内容的拷贝  ,对于像NSString,的确是这样.
但是,如果是copy的是一个NSArray呢?比如, 
NSArray *array = [NSArray arrayWithObjects:@"hello",@"world",@"baby"];
NSArray *array2 = [array copy]; 
这个时候,,系统的确是为array2开辟了一块内存空间,但是我们要认识到的是,array2中的每个元素,,只是copy了指向array中相对应元素的指针.这便是所谓的"浅复制".

assign与retain：

1.

接触过C，那么假设你用malloc分配了一块内存，并且把它的地址赋值给了指针a，后来你希望指针b也共享这块内存，于是你又把a赋值给
（assign）了b。此时a和b指向同一块内存，请问当a不再需要这块内存，能否直接释放它？答案是否定的，因为a并不知道b是否还在使用这块内存，如
果a释放了，那么b在使用这块内存的时候会引起程序crash掉。

2.
了解到1中assign的问题，那么如何解决？最简单的一个方法就是使用引用计数（reference
counting），还是上面的那个例子，我们给那块内存设一个引用计数，当内存被分配并且赋值给a时，引用计数是1。当把a赋值给b时引用计数增加到
2。这时如果a不再使用这块内存，它只需要把引用计数减1，表明自己不再拥有这块内存。b不再使用这块内存时也把引用计数减1。当引用计数变为0的时候，
代表该内存不再被任何指针所引用，系统可以把它直接释放掉。

总
结：上面两点其实就是assign和retain的区别，assign就是直接赋值，从而可能引起1中的问题，当数据为int,
float等原生类型时，可以使用assign。retain就如2中所述，使用了引用计数，retain引起引用计数加1,
release引起引用计数减1，当引用计数为0时，dealloc函数被调用，内存被回收。

NSString *pt = [[NSString alloc] initWithString:@"abc"];
上面一段代码会执行以下两个动作
1 在堆上分配一段内存用来存储@"abc"  比如：内存地址为：0X1111 内容为 "abc"
2 在栈上分配一段内存用来存储pt  比如：地址为：0Xaaaa 内容自然为0X1111  
下面分别看下assign retain copy
assign的情况：NSString *newPt = [pt assing];  
此时newPt和pt完全相同 地址都是0Xaaaa  内容为0X1111  即newPt只是pt的别名，对任何一个操作就等于对另一个操作。 因此retainCount不需要增加。
retain的情况：NSString *newPt = [pt retain];  
此时newPt的地址不再为0Xaaaa，可能为0Xaabb 但是内容依然为0X1111。 因此newPt 和 pt 都可以管理"abc"所在的内存。因此 retainCount需要增加1  
copy的情况：NSString *newPt = [pt copy];
此时会在堆上重新开辟一段内存存放@"abc" 比如0X1122 内容为@"abc 同时会在栈上为newPt分配空间 比如地址：0Xaacc 内容为0X1122 因此retainCount增加1供newPt来管理0X1122这段内存

//——————————————————————————
看了这么多也许大家有点晕， 现在进行实际的代码演示：

@property (nonatomic, assign) int number;
这里定义了一个int类型的属性， 那么这个int是简单数据类型，本身可以认为就是原子访问，所以用nonatomic,  不需要进行引用计数，所以用assign。 适用于所有简单数据类型。

@property (nonatomic, copy) NSString * myString;
这里定义了一个NSString类型的属性，不需要原子操作，所以用nonatomic.
为什么需要copy，而不是retain呢！
因为如果对myString赋值原字符串是一个可变的字符串(NSMutableString)对象的话，用retain的话，当原字符串改变的时候你的
myString属性也会跟着变掉。我想你不希望看到这个现象。 实际上博主测试，
如果原来的字符串是NSString的话，也只是retain一下，并不会copy副本

@property (nonatomic, retain) UIView * myView;
这里定义了一个UIView类型的属性，不需要原子操作，所以用nonatomic.
当对myView 赋值的时候原来的UIView对象retainCount会加1

//接口文件
@interface MyClass : NSObject
@property (nonatomic, assign)   int              number;
@property (nonatomic, copy)   NSString  * myString;
@property (nonatomic, retain) UIView    * myView;
@end

//实现文件
@implementation MyClass
@synthesize number;
@synthesize myString;
@synthesize myView;

//释放内存
-(void) dealloc
{
[myString release];  //copy的属性需要release;
[myView release];    //retain的属性需要release;

[super dealloc]; //传回父对象
}

@end

假如你有一段代码创建了一个MyClass对象

MyClass * instance  = [MyClass alloc] init];

//number赋值，没什么可说的， 简单数据类型就这样
instance.number = 1;

//创建一个可变字符串
NSMutableString * string = [NSMutableString stringWithString:@"hello"];

instance.myString = string;                   //对myString赋值

[string appendString:@" world!"];      //往string追加文本

NSLog(@”%@”,string);                        //此处string已经改变， 输出为 “hello world!”

NSLog(@”%@”,instance.myString);   //输出myString，你会发现此处输出仍然为 “hello” 因为 myString在string改变之前已经copy了一份副本

UIView * view = [[UIView alloc] init];
NSLog(@”retainCount = %d”,view.retainCount);
//输出view的引用计数， 此时为1

instance.myView = view; //对myView属性赋值

NSLog(@”retainCount = %d”,view.retainCount);
//再次输出view的引用计数， 此时为2，因为myView对view进行了一次retain。

[view release];
//此处虽然view被release释放掉了，但myView对view进行了一次retain，那么myView保留的UIView的对象指针仍然有效。

[instance release] ;