可变拷贝与不可变拷贝

1.拷贝的意义

            *  1、拷贝的目的 复制一个对象副本

         *  2、拷贝的种类:copy和mutableCopy,前者返回一个不可变对象,后则反之

         *  3、拷贝的性质:

         （1）当copy对象是不可变的对象时,那么copy的作用相当于retain

         例如：NSString *string  = [NSString stringWithFormat:@"demo"]; // 引用计数为 1

         NSString *copyStr = [string copy]; // 引用计数 2

         原因是：优化内存，因为当我们拷贝的对象是不可变时，意味着其内容不可改变。如果我们在内存中重新创建了一个副本，那么会显得毫无意义，浪费内存。

         （2）当我们使用mutableCopy对象，那么他就是真正意义上的拷贝(无论源对象是否可变)，即复制了一个对象副本

         例如：NSString *string  = [NSString stringWithFormat:@"demo"]; // 引用计数为 1

         NSMutableString *mCopyStr = [string mutableCopy]; // 引用计数 1

         (3)当我们拷贝的是可变的对象时，无论copy/mutableCopy，那么它的引用计数始终为1，实现了真正意义上的拷贝，即复制了一个对象的副本

         4、点语法

         @property (nonatomic, copy) NSString *name

         

         它的实现：

         - (void)setName:(NSString *)aName

         {

         if (_name != aName) {

         [_name release];

         _name = [string copy];

         }

         }

         这里我们需要注意以下几点：

         (1) 当我们传入的参数是不可变字符串对象时，那么copy，就是retain，其引用计数2

         (2) 当我们传入的参数是可变的字符串时，即创建了一个对象的副本，其引用计数为1

         (3) 我们需要注意：返回的这个对象始终是不可变的，

         (4) 如果我们需要返回一个可变的字符串，那么需要我们自己来实现

         它的实现：

         - (void)setName:(NSString *)aName

         {

         if (_name != string) {

         [_name release];

         _name = [string mutableCopy];

         }

         }

2.实例

#import <Foundation/Foundation.h>

#import "Person.h"

int main(int argc, const char * argv[])

{

    @autoreleasepool {

        

        // copy mutablCopy 用法

        /**

         * @ 1 copy mutablCopy 用法

         *     拷贝意义：修改源对象（副本对象），不会对副本对象（源对象）进行修改

         */

        // 不可变->可变

        //源对象

        NSString *name=[[NSString alloc] initWithFormat:@"Jack"];

        NSLog(@"name : %@",name);

        //副本对象

        NSMutableString *newName=[name mutableCopy];

        

        NSLog(@"newName1 : %@",newName);

        [newName appendString:@" rose"];

        NSLog(@"newName2 : %@",newName);

        [name release];

        [newName release];

       

        //可变->不可变

        //源对象

        NSMutableString *name2=[[NSMutableString alloc] initWithFormat:@"fanfan"];

        NSLog(@"name : %@",name2);

        //副本对象

        NSString *newName2=[name2 copy];

        NSLog(@"newName : %@ ",newName2);

        [name2 release];

        [newName2 release];

        

        NSLog(@"---------------------------");

        

        NSMutableArray *mutableArray=[NSMutableArray arrayWithObjects:@"one",@"two",@"three", nil];

        NSMutableArray *retainArray=[mutableArray retain];

        [retainArray removeLastObject];

        for (NSString *element in retainArray) {

            NSLog(@"%@",element);

        }

        [retainArray release];

        

        

        NSMutableArray *mutableArray2=[NSMutableArray arrayWithObjects:@"one",@"two",@"three", nil];

        NSMutableArray *copyArray=[mutableArray2 mutableCopy];

        [copyArray removeLastObject];        //副本数组删一个对象,源数组的不变,这刚好符合拷贝的意义

        for (NSString *element in mutableArray2) {

            NSLog(@"%@",element);

        }

        [copyArray release];

        

        

        NSMutableString *one=[[NSMutableString alloc] initWithString:@"one"];

        NSMutableString *two=[[NSMutableString alloc] initWithString:@"two"];

        

        NSArray *arr=@[one,two];

        NSMutableArray *copyArr=[arr mutableCopy];

        NSMutableString *str=copyArr[0];

        [str appendString:@"zero"];

        NSLog(@"one : %@",one);

        NSLog(@"str : %@",str);

        [one release];

        [two release];

        [copyArr release];

        

  

    }

    return 0;

}