Menu
Woocommerce Menu

对于不可变对象是浅复制3522vip靠谱吗,对象属性包含的对象不复制

0 Comment

objective-c中的深、浅拷贝,objective-c拷贝

浅复制:只复制指向对象的指针,而不复制援引对象自己。计数器+1
,就像比如retain

深层复制:复制征引对象自己。计数器不变,爆发新目的 

 

retain:始终是浅复制。引用计数每一次加一。重回对象是或不是可变与被复制的对象保持一致。

 

copy:对于可变对象为深复制,引用计数不退换;对于不可变对象是浅复制,援用计数每一次加一。始终返回二个不可变对象。

mutableCopy:始终是深复制,援用计数不改换。始终再次回到八个可变对象。

 

3522vip靠谱吗 1#import
<Foundation/Foundation.h> int main(int argc, const char *
argv[]) { NSMutableArray *array1=[NSMutableArray
arrayWithObjects:@”two day”, nil]; NSMutableArray *array2=[array1
copy]; NSArray *array3=[array2 copy]; NSArray *array4=[array2
retain]; NSMutableArray *array5=[array1 retain]; NSMutableArray
*array6=[array1 mutableCopy]; NSArray *array7=[array2
mutableCopy]; NSLog(@”————-“); NSLog(@”array1:%@ %p”,array1,
array1); NSLog(@”array2:%@ %p”,array2, array2); NSLog(@”array3:%@
%p”,array3, array3); NSLog(@”array4:%@ %p”,array4, array4);
NSLog(@”array5:%@ %p”,array5, array5); NSLog(@”array6:%@ %p”,array6,
array6); NSLog(@”array7:%@ %p”,array7, array7); NSLog(@”————-“);
return 0; } 源代码

 

3522vip靠谱吗 22015-04-01
20:46:23.131 04-01-person[2204:165655] ————- 2015-04-01
20:46:23.132 04-01-person[2204:165655] array1:( “two day” )
0x100114570 2015-04-01 20:46:23.133 04-01-person[2204:165655] array2:(
“two day” ) 0x100114700 2015-04-01 20:46:23.133
04-01-person[2204:165655] array3:( “two day” ) 0x100114700 2015-04-01
20:46:23.133 04-01-person[2204:165655] array4:( “two day” )
0x100114700 2015-04-01 20:46:23.133 04-01-person[2204:165655] array5:(
“two day” ) 0x100114570 2015-04-01 20:46:23.133
04-01-person[2204:165655] array6:( “two day” ) 0x1001150d0 2015-04-01
20:46:23.134 04-01-person[2204:165655] array7:( “two day” )
0x100115b00 2015-04-01 20:46:23.134 04-01-person[2204:165655]
————- Program ended with exit code: 0 运转结果

 

数组类型转变:

1、不可变对象→可变对象的改变:       

3522vip靠谱吗 3#import
<Foundation/Foundation.h> int main(int argc, const char *
argv[]) { NSArray *array01=[NSArray
arrayWithObjects:@”zhang”,@”wang”,@”li”, nil]; NSMutableArray
*array02=[array01 mutableCopy]; //mutableCopy始终重返八个可变对象
NSLog(@”array01: %@ %p”,array01,array01); NSLog(@”array02: %@
%p”,array02,array02); return 0; } 源代码
3522vip靠谱吗 42015-04-01
21:00:28.218 04-01-person[2252:170414] array01: ( zhang, wang, li )
0x100106c80 2015-04-01 21:00:28.220 04-01-person[2252:170414] array02:
( zhang, wang, li ) 0x1001076d0 Program ended with exit code: 0 运营结果

 

2、可变对象→不可变对象的调换:

3522vip靠谱吗 5#import
<Foundation/Foundation.h> int main(int argc, const char *
argv[]) { NSMutableArray *array1 = [NSMutableArray
arrayWithObjects:@”zhang”,@”wang”,@”li”, nil]; NSArray
*array2=[array1
copy];//copy对于可变对象为深复制,引用计数不转移;对于不可变对象是浅复制,援引计数每一趟加一。始终再次回到三个不可变对象
NSLog(@”array1: %@ %p”,array1,array1); NSLog(@”array2: %@
%p”,array2,array2); return 0; } 源代码
3522vip靠谱吗 62015-04-01
21:03:45.349 04-01-person[2263:171615] array1: ( zhang, wang, li )
0x100112900 2015-04-01 21:03:45.350 04-01-person[2263:171615] array2:
( zhang, wang, li ) 0x1001133b0 运维结果

 

3、可变对象→可变对象的改造(不相同指针变量指向分歧的内部存款和储蓄器地址):

3522vip靠谱吗 7#import
<Foundation/Foundation.h> int main(int argc, const char *
argv[]) { NSMutableArray *array1= [NSMutableArray
arrayWithObjects:@”zhang”,@”wang”,@”li”, nil]; NSMutableArray
*array2=[array1 mutableCopy]; NSLog(@”array1: %@ %p”,array1,array1);
NSLog(@”array2: %@ %p”,array2,array2); return 0; } 源代码
3522vip靠谱吗 82015-04-01
20:57:41.732 04-01-person[2243:169571] array1: ( zhang, wang, li )
0x100114570 2015-04-01 20:57:41.734 04-01-person[2243:169571] array2:
( zhang, wang, li ) 0x100115020 Program ended with exit code: 0 运维结果

 

 

4、同品种对象时期的指针复制(不一致指针变量指向同一块内存地址):

3522vip靠谱吗 9#import
<Foundation/Foundation.h> int main(int argc, const char *
argv[]) { NSArray *array1=[NSArray
arrayWithObjects:@”one”,@”two”,@”three”, nil]; NSArray
*array2=[array1 copy]; NSLog(@”array1: %@ %p”,array1,array1);
NSLog(@”array2: %@ %p”,array2,array2); return 0; } 源代码
3522vip靠谱吗 102015-04-01
20:53:07.398 04-01-person[2217:167996] array1: ( one, two, three )
0x1006069a0 2015-04-01 20:53:07.399 04-01-person[2217:167996] array2:
( one, two, three ) 0x1006069a0 Program ended with exit code: 0 运转结果

当多少个指针同一时间针对同一块内部存款和储蓄器区域,那么那个个指针同不平日间具有对该内部存款和储蓄器区的全数权。全体权的分开进程,那时候将要用到浅拷贝了。

 

 

 

 

 

 

浅复制: 只复制指向对象的指针,而不复制援引对象自己。计数器+1
,就如比如retain 深层复制:复…

@end

//继续copy后援用计数为:::::::::::3

5.哪一天用浅拷贝和深拷贝?

浅拷贝是要复制二个对象的指针

深拷贝是将贰个目的可变转为不可变,或是将贰个对象不可变转为可变,或将目标的剧情克隆一份。

NSMutableArray *copyItems = [[NSMutableArray alloc]
initWithArray:oldArray copyItems:YES];

NSArray *arrayCopy3 = [array1 mutableCopy];

7.结论

//结论:mutableCopy拷贝出来的指标为NSMutableString
,NSMutableArray,NSMutableDictionary

//不可变对象copy拷贝出来的靶子为NSString,NSArray,NSDictionary,地址拷贝,

//可变对象copy拷贝出来的靶子为不可变对象

                         //    NSMutableArray *marray = [arrayValue
copy];//error

                           NSMutableString *NMstrCopy= [nmstr
copy];

                      //    [NMstrCopy appendString:@”123″];//error

//不可变对象mutablecopy拷贝出来为不可变对象

NSString* strMutableHello =[strSourceHello
mutableCopy];//地址不相同,内容同样

{

//copy复制::::::::::0x100102720//深复制

2.copy和retain的区别

copy是创办多少个新指标,retain是创建一个指南针,援用对象计数加1,

copy表示五个指标内容一致,新指标计数为1,旧目的未有成形

retain表示七个目的地址同样(营造一个指南针,指针拷贝)

copy是内容拷贝,对于可变数组,属于深拷贝,计数不改变,对于不可变数组,属于浅拷贝,计数加1。

retain是指针拷贝.属于浅拷贝,计数加1,不发生新的对象。

例如:

一个NSString 对象地址为0X11111,内容为@”str”;

copy到其余二个对象,地址为0x2222,内容为@”str”,修改新的靶子,对旧目的未有影响。

retain到别的一个指标,地址同样,同为0x11111

注意:

当NSCopy复制二个不行变数组时,属于浅拷贝,其他情状属于深拷贝;

当使用NSMutableCopy时,是深拷贝;

若果自定义类要想落成拷贝动作,必须信守NSCopy和NSMutableCopy共同商议。

假诺拷贝的是NSObject对象,须求重写:

-(id)copyWithZone:(NSZone *)zone

-(id)mutableCopyWithZone:(NSZone *)zone

//第二种:容器类不可变对象拷贝

 

4.NSMutableCopy、NScopy

假定是NSMutableCopy时,无论对象是或不是可变,副本是能够变的。

举个例子是NSCopy时,尽管是可变对象,别本对象是不可变的。

一经自定义多个copy,那么必须信守NSCopying並且落成copyWithZone:方法

//mutableCopy拷贝出来的目的为NSMutableString
,NSMutableArray,NSMutableDictionary

//copy拷贝出来的指标为NSString,NSArray,NSDictionary,

2017-02-17 10:29:18.065 InteviewTestCode[18973:524282] array_p =
0x608000036600

NSArray *array1= [NSArray arrayWithObjects:@”a”,@”b”,@”c”,@”d”,nil];

3.深正片和浅拷贝的本质差距

是目的可能指标的品质地址是不是同样,倘若同样则为浅拷贝,不雷同为深拷贝。

Foundation帮助复制的类,默以为浅拷贝。

深拷贝拷贝出来的目的与源对象地址不均等,修改拷贝对象不影响源对象

浅拷贝拷贝出来的靶子与源对象地址同样,修改拷贝对象会影响到源对象

copy就是复制了二个imutable(不可改动)的对象,

mutablecopy正是复制了三个mutable(可变的)的对象

key2 = “new_value1”;

 

6.示例

示例1:

//copy重返不可变对象,mutablecopy重临可变对象

NSArray* arrayValue= [NSArray arrayWithObjects:@”1″,@”2″,@”3″, nil];

NSArray* arrayCopy = [arrayValue copy];

NSLog(@”array:%p,arrayCopy:%p”,arrayValue,arrayCopy);

//array:0x608000241cb0,arrayCopy:0x608000241cb0

NSMutableArray *marray = [arrayValue mutableCopy];

[marray addObject:@”de”];

[marray removeObjectAtIndex:0];

NSLog(@”arrayValue:%@,marray:%@”,arrayValue,marray);

//arrayValue:(1,2,3) marray:(2,3,de)

//copy指针拷贝,mutableCopy拷贝二个新的别本,对本来的从没有过影响

示例2:

/**************************copy/mutableCopy
NSObject**************************/   
ViewController *vc = [[ViewController alloc]init];    vc.name =
@”HelloWorld”;    ViewController *vcCopy = [vc
copy];//未有重写-(id)copyWithZone:(NSZone
*)zone这几个格局分配空间会闪退   
NSLog(@”vc:%@,copy:%@”,vc,vcCopy);//vc:,copy:NSLog(@”vcName:%@,copyName:%@”,vc.name,vcCopy.name); 
  //深拷贝        ViewController *vcMutableCopy= [vc
mutableCopy];//未有重写-(id)mutableCopyWithZone:(NSZone
*)zone这些办法申请空间会闪退   
NSLog(@”vc:%@,mutableCopy:%@”,vc,vcMutableCopy);//vc:,mutableCopy:NSLog(@”vcName:%@,MutablecopyName:%@”,vc.name,vcMutableCopy.name);

//往字典中投入新的值

1、不可变对象→可变对象的调换:

1.浅拷贝和深拷贝的区分

浅拷贝只是复制对象自己,对象属性包罗的靶子不复制,不发生新目的,直接指向原有对象。

深拷贝复制对象自己,同事属性也复制,产生新的指标,与原有对象内容一样

2014-08-13 16:33:00.754 OC6-1[3942:303] 0x1002047c0

//初步化赋值引用计数为::::::::::1

//用copyItems拷贝数组中的成分

//继续mutableCopy后援引计数为::2

 

   NSMutableString *str2=[str1   retain];

NSLog(@”m_array_p2[0] = %p”, m_array2[0]);

printf(“\ncopy复制::::::::::%p”,strCpy2);

2.非容器 + 可变对象 + retain + copy + mutableCopy

// 初叶化赋值援引计数为:18446744073709551615

然后再重写-(id) copyWithZone : (NSZone *) zone  和 -(id)mutableCopyWithZone : (NSZone *) zone

重写-(id) copyWithZone :(NSZone *)zone方法如下

 

2017-02-17 09:57:02.692 InteviewTestCode[18890:507384] s2_p =
0xa6968736164756c7

 

//用就得数组生成新的数组

跟赋值概念完全不一致,即使这里看起来很像。

//新建八个测量检验字符串

透过下面的五个例证,我们可轻易的将八个对象在可变和不可变之间转变,並且这里并不是思考内部存款和储蓄器使用口径(即援引计数的主题素材)。没有错,这正是深拷贝的魅力了。

2017-02-17 10:29:18.079 InteviewTestCode[18973:524282]
打印输出各个可变容器兰月素的地址

 

NSMutableArray *multable = [NSKeyedUnarchiver
unarchiveObjectWithData:data];

2、可变对象→不可变对象的更改:

NSMutableString *string = [NSMutableString
stringWithFormat:@”ludashi”];

printf(“\n”);

2017-02-17 10:29:18.079 InteviewTestCode[18973:524282] m_array_p2 =
0x60800001a0a0

实际我们都看出来了,这里是指针变量,只存在“指针的复制”,

NSString *str = @"InteviewTestCode";

//把str通过copy的方式把值赋给str2

NSString *str2 = [str copy];

//把str通过mutableCopy的方式把值赋给str3

NSString *str3 = [str mutableCopy];


//分别输出每个字符串的内存地址

NSLog(@" str-p = %p", str);

NSLog(@"str2-p = %p", str2);

NSLog(@"str3-p = %p", str3);

   NSArray  *str2=[array1 Copy];

接下去我们来测量检验下非容器类的可变对象的深浅拷贝

   可变对象:无论值是还是不是变动,其内部存款和储蓄器首地址都不随之改造。

4.容器类可变对象: 举个例子NSMutableArray

 

)

NSMutableString *strCpy3=[str2 mutableCopy];

[dic setObject:str forKey:@”key1″];

4、同品种对象之间的指针复制(分歧指针变量指向同一块内部存款和储蓄器地址):

2017-02-17 10:29:18.079 InteviewTestCode[18973:524282]
m_array_p[0] = 0x608000074340

printf(“\n继续retain援引计数为:::%lu”,str1.retainCount);

return test;

   [array1 release];

{

 

代码如下:

// 继续copy后援引计数为:18446744073709551615

//每一个数组的地方为:

//继续mutableCopy后引用计数为::::3

2017-02-17 10:29:18.066 InteviewTestCode[18973:524282] array3_p =
0x6080000498d0

//nmutableCopy复制:::0x10010e7c0 0x1000034b0//深复制

2014-08-13 16:33:00.753 OC6-1[3942:303] (

NSArray *arrayCopy2 = [array1 copy];

容器类的非可变对象:

copy拷贝获得的对象的地址和原有对象的地址一致

2.而mutableCopy拷贝返回新的内存地址,并且返回的对象为可变对象

3.而容器内对象的地址总是一样的,不受copy,mutableCopy影响

**4.容器类 +  可变对象 + retain + copy + mutableCopy**

下面对容器类的可变对象进行测试,copy和mutableCopy对于容器本身是深拷贝,原因是返回了一个新的容器地址,但对于容器中的元素仍然是浅拷贝。

代码如下:

          3、指南针复制俗称指针拷贝,对象复制也俗称内容拷贝。

2017-02-17 10:29:18.080 InteviewTestCode[18973:524282]
m_array_p3[0] = 0x608000074340

mutableCopy:始终是深复制,引用计数不变。始终重临一个可变对象。

//分别出口每个区域

 

容器类的可变对象:

1.copy:对于可变对象为深复制,引用计数不改变;对于不可变对象是浅复制, 引用计数每次加一。始终返回一个不可变对象。

2.mutableCopy:始终是深复制,引用计数不改变。始终返回一个可变对象。

**5.自定义类对象之间的深浅拷贝问题**

在Objective-C中并不是所有的类都支持拷贝;只有遵循NSCopying协议的类,才支持copy拷贝,只有遵循NSMutableCopying协议的类,才支持mutableCopy拷贝。如果没有遵循拷贝协议,拷贝时会出错。

如果我们想再我们自定义的类中支持copy和mutableCopy那么我们就需要使我们定义的类遵循NSCopying和NSMutableCopying协议,代码如下:

//继续retain后援用计数为:::::::::2

NSLog(@”%p”, copyItems);

 

NSData * data = [NSKeyedArchiver
archivedDataWithRootObject:oldArray];

 

//把字典存入数组中

 

2014-08-13 16:33:00.754 OC6-1[3942:303] 0x100204560

//这里表达该项目官样文章引用计数的概念

运行结果:

NSString *strCopy2=*str1;

1.retian对对可变对象为浅拷贝

2.copy对可变对象非容器类为深拷贝

3.mutableCopy对可变非容器类为深拷贝

**3.容器类 +  非可变对象 + retain + copy + mutableCopy**

容器类的非可变对象进行测试:容器需要特别注意的是容器本身和容器内的对象分别是什么结果,(1)从容器对象看而言是容器的深拷贝, (2)但从输出容器中的元素是容器的浅拷贝(所以下面代码并不是容器真正意义上的的完全拷贝,本文最后做介绍)。

 

}

printf(“\nnmutableCopy复制:::%p\t%p”,arrayCpy3,[arrayCpy3
objectAtIndex:1]);

     浅拷贝是在要复制三个对象的指针时用到。

[dic setObject:@”new_value1″ forKey:@”key2″];

问:曾几何时用到深浅拷贝?

}

赋值进程:输入数据→贮存器管理→开垦内部存款和储蓄器→写入数据。

2017-02-17 10:29:18.079 InteviewTestCode[18973:524282] m_array_p3 =
0x608000049300

//开首化赋值援引计数为::::::::::::1

2017-02-17 10:29:18.078 InteviewTestCode[18973:524282] array3_p[0]
= 0x608000074340

 

//把array通过mutableCopy形式把值赋给array3

printf(“\n开头化赋值引用计数为::::::::::%lu”,array2.retainCount);

1.retain:始终是浅复制。引用计数每次加一。再次回到对象是还是不是可变与被复制的指标保持一致。(所在此以前面不再比方,供给测量试验的在手动处理上)

答:深拷贝是在要将三个指标从可变(不可变)转为不可变(可变)恐怕将一个对象内容克隆一份时用到;

NSLog(@”%p”, oldArray);

//mutableCopy复制:::0x10010c760 0x100003410//深复制

2014-08-13 16:33:00.753 OC6-1[3942:303] (

printf(“\n”);

发表评论

电子邮件地址不会被公开。 必填项已用*标注

相关文章

网站地图xml地图