ios中strong, weak, assign, copy

copy 和 strong(retain) 区别

1. http://blog.csdn.net/itianyi/article/details/9018567

大部分的时候NSString的属性都是copy，那copy与strong的情况下到底有什么区别呢?

比如：

@property (retain,nonatomic) NSString *rStr;

@property (copy, nonatomic)   NSString *cStr;

- (void)test:

{

NSMutableString *mStr = [NSMutableStringstringWithFormat:@"abc"];

self.rStr   = mStr;

self.cStr     = mStr;

NSLog(@"mStr:%p,%p",  mStr,&mStr);

NSLog(@"retainStr:%p,%p", _rStr, &_rStr);

NSLog(@"copyStr:%p,%p",   _cStr, &_cStr);

｝

假如，mStr对象的地址为0x11，也就是0x11是@“abc”的首地址，mStr变量自身在内存中的地址为0x123；

当把mStr赋值给retain的rStr时，rStr对象的地址为0x11，rStr变量自身在内存中的地址为0x124；rStr与mStr指向同样的地址，他们指向的是同一个对象@“abc”，这个对象的地址为0x11，所以他们的值是一样的。

当把mStr赋值给copy的cStr时，cStr对象的地址为0x22，cStr变量自身在内存中的地址0x125；cStr与mStr指向的地址是不一样的，他们指向的是不同的对象，所以copy是深复制，一个新的对象，这个对象的地址为0x22，值为@“abc”。

如果现在改变mStr的值：

[mStr appendString:@"de"];

NSLog(@"retainStr:%@",  _rStr);

NSLog(@"copyStr:%@",    _cStr);

结果，

使用retain的字串rStr的值：@"abcde",

而使用copy的字串cStr的值:@"abc",

所以，如果一般情况下，我们都不希望字串的值跟着mStr变化，所以我们一般用copy来设置string的属性。

如果希望字串的值跟着赋值的字串的值变化，可以使用strong，retain。

注意：上面的情况是针对于当把NSMutableString赋值给NSString的时候，才会有不同，如果是赋值是NSString对象，那么使用copy还是strong，结果都是一样的，因为NSString对象根本就不能改变自身的值，他是不可变的。

把一个对象赋值给一个属性变量，当这个对象变化了，如果希望属性变量变化就使用strong属性，如果希望属性变量不跟着变化，就是用copy属性。

由此可以看出：

对源头是NSMutableString的字符串，retain仅仅是指针引用，增加了引用计数器，这样源头改变的时候，用这种retain方式声明的变量（无论被赋值的变量是可变的还是不可变的），它也会跟着改变;而copy声明的变量，它不会跟着源头改变，它实际上是深拷贝。

对源头是NSString的字符串，无论是retain声明的变量还是copy声明的变量，当第二次源头的字符串重新指向其它的地方的时候，它还是指向原来的最初的那个位置，也就是说其实二者都是指针引用，也就是浅拷贝。

另外说明一下，这两者对内存计数的影响都是一样的，都会增加内存引用计数，都需要在最后的时候做处理。

其实说白了，对字符串为啥要用这两种方式？我觉得还是一个安全问题，比如声明的一个NSString *str变量，然后把一个NSMutableString *mStr变量的赋值给它了，如果要求str跟着mStr变化，那么就用retain;如果str不能跟着mStr一起变化，那就用copy。而对于要把NSString类型的字符串赋值给str，那两都没啥区别。不会影响安全性，内存管理也一样。

2.

IOS的对象都继承于NSObject, 该对象有一个方法:retainCount ，内存引用计数。 引用计数在很多技术都用到: window下的COM组件，多线程的信号量，读写锁，思想都一样。

(一般情况下: 后面会讨论例外情况)
alloc 对象分配后引用计数为1
retain 对象的引用计数+1
copy copy 一个对象变成新的对象(新内存地址) 引用计数为1 原来对象计数不变

release 对象引用计数-1 如果为0释放内存
autorelease 对象引用计数-1 如果为0不马上释放，最近一个个pool时释放
NSLog(@"sMessage retainCount:%u",[sMessage retainCount]);

内存管理的原则就是最终的引用计数要平衡，
如果最后引用计数大于0 则会内存泄露
如果引用 计数等于0还对该对象进行操作，则会出现内存访问失败，crash 所以尽量设置为nil

这两个问题都很严重，所以请一定注意内存释放和不用过后设置为nil

成员变量与属性
实际情况并非上面那么简单，你可能需要在一个函数里调用另一个函数分配的变量这时候
有两个选择: 类成员变量和使用属性
@interface TestMem: NSObject {
TestObject *m_testObject ; // 成员变量
TestObject *testObject; //成员变量
}
成员变量与上面的内存管理是一致的，只是在不同的函数里要保持引用计数加减的平衡
所以要你要每次分配的时候检查是否上次已经分配了。是否还能调用
什么时候用属性?
1. 把成员做为public.
2. outlet 一般声明为属性( 这个内存于系统控制，但我们还是应该做一样操作，后面会讲)
3. 如果很多函数都需要改变这个对象 ，或这个函数会触发很多次，建议使用属性。我们看看属性函数展开后是什么样子:

// assign
-(void)setTestObject :(id)newValue{
testObject= newValue;
}
// retain
-(void)setTestObject :(id)newValue{
if (testObject!= newValue) {
[testObject release];
testObject= [newValue retain];
}
}
// copy
-(void)setTestObject :(id)newValue{
if (testObject != newValue) {
[testObject release];
testObject = [newValue copy];
}
}
asssign 相于于指针赋值，不对引用计数进行操作，注意原对象不用了，一定要把这个设置为nil
retain 相当于对原对象的引用计数加1
copy 不对原对象的引用计数改变，生成一个新对象引用计数为1
注意:
self.testObject 左值调用的是setTestObject 方法. 右值为get方法，get 方法比较简单不用说了
而 真接testObject 使用的是成员变量
self.testObject = [[testObject alloc] init]; // 错 reatin 两次
testObject = [NSArray objectbyindex:0]; //错 不安全，没有retain 后面release会出错
如果testObject已有值也会mem leak

自动管理对象
IOS 提供了很多static(+) 创建对象的类方法，这些方面是静态的，可以直接用类名
调用如:
NSString *testString = [NSString stringWithFormat:@"test" ];
testString 是自动管理的对象，你不用relese 他，他有一个很大的retain count, release后数字不变。

5. 例外
有一些通过alloc 生成的对象相同是自动管理的如:
NSString *testString = [[NSString alloc] initWithString:@"test1"];
retain count 同样是很大的数，没办法release
但为了代码对应，还是应该加上[ testString release];
不然xcode的Analyze 会认识内存leak, 但Instruments leak 工具检测是没有的

IOS内存管理详解

copy 和 retain 的区别
copy： 建立一个索引计数为1的对象，然后释放旧对象
retain：释放旧的对象，将旧对象的值赋予输入对象，再提高输入对象的索引计数为1
那上面的是什么该死的意思呢？
Copy其实是建立了一个相同的对象，而retain不是：
比如一个NSString对象，地址为0×1111，内容为@”STR”
Copy到另外一个NSString之后，地址为0×2222，内容相同，新的对象retain为1，旧有对象没有变化
retain到另外一个NSString之后，地址相同（建立一个指针，指针拷贝），内容当然相同，这个对象的retain值+1
也就是说，retain是指针拷贝，copy是内容拷贝。哇，比想象的简单多了…

strong 和weak

iOS 5 中对属性的设置新增了strong 和weak关键字来修饰属性（iOS 5 之前不支持ARC）

strong 用来修饰强引用的属性；

@property (strong) SomeClass * aObject;
对应原来的
@property (retain) SomeClass * aObject; 和 @property (copy) SomeClass * aObject;

weak 用来修饰弱引用的属性；
@property (weak) SomeClass * aObject;
对应原来的
@property (assign) SomeClass * aObject;

unsafe_unretained

unsafe_unretained 就是ios5版本以下的 assign ，也就是 unsafe_unretained ， weak， assign 三个都是一个样的。 因为 ios5用的是 weak ，那在ios4.3就用不了，如果你将 weak 修改为 unsafe_unretained ，那就可以用了。说到底就是iOS 5之前的系统用该属性代替 weak 来使用。

copy：这个东西估计是大部分人最不容易搞明白的东西，我也搞不明白。听别人说这个东西基本不用了，效果其实和retain没什么两样，唯一的区别就是copy只用于NSString而不能用于NSMutableString。

不过好像当一个类继承NSObject，那么这个类里面的属性需要使用copy，比如：

#import <Foundation/Foundation.h>

#import <MapKit/MKAnnotation.h>

@interface Annotation : NSObject <MKAnnotation> {

CLLocationCoordinate2D coordinate;

NSString *title;

NSString *subtitle;

}

@property (nonatomic) CLLocationCoordinate2D coordinate;

@property (nonatomic, copy) NSString *title;

@property (nonatomic, copy) NSString *subtitle;

@end

反正以后就这么用就是了

property的属性默认是：readwrite，assign, atomic(没有这个关键字

在MRC下使用assign修饰代理属性,避免循环引用,在ARC下使用weak

代理使用weak而不使用assign的原因：

I just ran into this problem and solved it. For ARC, the solution is to use the weak attribute instead of assign.

The crash come because the delegate

Has an assign attribute, AND

Has been deallocated.

Thus when you attempt to call the respondsToSelector method on delegate, you get a EXC_BAD_ACCESS. This is because objects that use the assign property will not be set to nil when they are deallocated. (Hence why doing a !self.delegate before the respondsToSelector does not prevent the responseToSelector from being called on a deallocated object, and still crashes your code)

The solution is to use the weak attribute, because when the object deallocates, the pointer WILL be set the nil . So when your code calls respondsToSelector on a nil, Objective C will ignore the call, and not crash.

As already mentioned, using a strong or assign attribute on a delegate (as many have mentioned) in ARC will result in a retain cycle. So don't do it, you don't need to.

3. http://blog.csdn.net/itianyi/article/details/9018567

@property (nonatomic, assign) NSString *title;

什么是assign，copy，retain之间的区别？

assign： 简单赋值，不更改索引计数（Reference Counting）。

copy： 建立一个索引计数为1的对象，然后释放旧对象

retain：释放旧的对象，将旧对象的值赋予输入对象，再提高输入对象的索引计数为1

weak 和strong的区别：

（weak和strong）不同的是 当一个对象不再有strong类型的指针指向它的时候 它会被释放  ，即使还有weak型指针指向它。

一旦最后一个strong型指针离去 ，这个对象将被释放，所有剩余的weak型指针都将被清除。

可能有个例子形容是妥当的。

想象我们的对象是一条狗，狗想要跑掉（被释放）。

strong型指针就像是栓住的狗。只要你用牵绳挂住狗，狗就不会跑掉。如果有5个人牵着一条狗（5个strong型指针指向1个对象），除非5个牵绳都脱落 ，否着狗是不会跑掉的。

weak型指针就像是一个小孩指着狗喊到：“看！一只狗在那” 只要狗一直被栓着，小孩就能看到狗，（weak指针）会一直指向它。只要狗的牵绳脱落，狗就会跑掉，不管有多少小孩在看着它。

只要最后一个strong型指针不再指向对象，那么对象就会被释放，同时所有的weak型指针都将会被清除。

使用assign: 对基础数据类型 （NSInteger，CGFloat）和C数据类型（int, float, double, char, 等等）

使用copy： 对NSString

使用retain： 对其他NSObject和其子类

nonatomic关键字：

atomic是Objc使用的一种线程保护技术，基本上来讲，是防止在写未完成的时候被另外一个线程读取，造成数据错误。而这种机制是耗费系统资源的，所以在iPhone这种小型设备上，如果没有使用多线程间的通讯编程，那么nonatomic是一个非常好的选择。