The page is temporarily unavailable
nginx error!
The page you are looking for is temporarily unavailable.
Please try again later.
Website Administrator
Something has triggered an error on your
This is the default error page for
nginx that is distributed with
It is located
/usr/share/nginx/html/50x.html
You should customize this error page for your own
site or edit the error_page directive in
the nginx configuration file
/etc/nginx/nginx.conf.博客访问： 116360
博文数量： 91
博客积分： 3956
博客等级： 中校
技术积分： 665
注册时间：
IT168企业级官微
微信号：IT168qiye
系统架构师大会
微信号：SACC2013
分类： C/C++
<font class="Apple-style-span" color="#.&深拷贝是指源对象与拷贝对象互相独立，其中任何一个对象的改动都不会对另外一个对象造成影响。举个例子，一个人名叫张三，后来用他克隆（假设法律允许）了另外一个人，叫李四，不管是张三缺胳膊少腿还是李四缺胳膊少腿都不会影响另外一个人。比较典型的就是Value（值）对象，如预定义类型Int32，Double，以及结构（struct），枚举（Enum）等。考虑以下写法：&&&&&&&int&source =&int.MaxV//(1)初始化源对象为整数的最大值2,147,483,647&&&&&&&&&&&&int&dest =//(2)赋值，内部执行深拷贝&&&&&&&&&&&&dest = 1024;//(3)对拷贝对象进行赋值&&&&&&&&&&&&source = 2048;//(4)对源对象进行赋值&& &首先（<font class="Apple-style-span" color="#）中将source赋给dest，执行了深拷贝动作，其时dest和source的值是一样的，都是int.MaxValue；（<font class="Apple-style-span" color="#）对dest进行修改，dest值变为<font class="Apple-style-span" color="#24，由于是深拷贝，因此不会运行source，source仍然是int.MaxValue；（<font class="Apple-style-span" color="#）对source进行了修改，同样道理，dest仍然是<font class="Apple-style-span" color="#24，同时int.MaxValue的值也不变，仍然是<font class="Apple-style-span" color="#,147,483,647；只有source变成了<font class="Apple-style-span" color="#48。&&&&&再考虑以下写法：
struct Point
&&&&&&&&&&&&public int X;
&&&&&&&&&&&&public int Y;
&&&&&&&&&&&&public Point(int x, int y)
&&&&&&&&&&&&{
&&&&&&&&&&&&&&&&X =
&&&&&&&&&&&&&&&&Y =
&&&&&&&&&&&&}
&&&&&&&&Point source = new Point(10, 20);
&&&&&&&&Point dest =
&&&&&&&&dest.X = 20&当dest.X属性变成20后，source的X属性仍然是10<font class="Apple-style-span" color="#. &&浅拷贝是指源对象与拷贝对象共用一份实体，仅仅是引用的变量不同（名称不同）。对其中任何一个对象的改动都会影响另外一个对象。举个例子，一个人一开始叫张三，后来改名叫李四了，可是还是同一个人，不管是张三缺胳膊少腿还是李四缺胳膊少腿，都是这个人倒霉。比较典型的就有Reference（引用）对象，如Class（类）。考虑以下写法：class Point
&&&&&&&&&&&&public int X;
&&&&&&&&&&&&public int Y;
&&&&&&&&&&&&public Point(int x, int y)
&&&&&&&&&&&&{
&&&&&&&&&&&&&&&&X =
&&&&&&&&&&&&&&&&Y =
&&&&&&&&&&&&}
&&&&&&&&Point source = new Point(10, 20);
&&&&&&&&Point dest =
&&&dest.X = 20;由于Point现在是引用对象，因此Point dest=source的赋值动作实际上执行的是浅拷贝，最后的结果应该是source的X字段值也变成了20。即它们引用了同一个对象，仅仅是变量明source和dest不同而已。<font class="Apple-style-span" color="#. 引用对象的浅拷贝原理引用对象之间的赋值之所以执行的是浅拷贝动作，与引用对象的特性有关，一个引用对象一般来说由两个部分组成。（<font class="Apple-style-span" color="#）一个具名的Handle，也就是我们所说的声明（如变量）（<font class="Apple-style-span" color="#）一个内部（不具名）的对象，也就是具名Handle的内部对象。它在Manged Heap（托管堆）中分配，一般由新增引用对象的New方法是进行创建。&&&&&&&如果这个内部对象已被创建，那么具名的Handle就指向这个内部对象在Manged Heap中的地址，否则就是null（从某个方面来讲，如果这个具名的handle可以被赋值为null，说明这是一个引用对象，当然不是绝对）。两个引用对象如果进行赋值，它们仅仅是复制这个内部对象的地址，内部对象仍然是同一个，因此，源对象或拷贝对象的修改都会影响对方。这也就是浅拷贝。4. &引用对象如何进行深拷贝由于引用对象的赋值仅仅是复制具名。Handle（变量）指向的地址，因此要对引用对象进行深拷贝就要重新创建一份该对象的实例，并对该对象的字段进行逐一赋值，如以下写法： class Point
&&&&&&&&&&&&public int X;
&&&&&&&&&&&&public int Y;
&&&&&&&&&&&&public Point(int x, int y)
&&&&&&&&&&&&{
&&&&&&&&&&&&&&&&X =
&&&&&&&&&&&&&&&&Y =
&&&&&&&&&&&&}
&&&&&&&&Point source = new Point(10, 20);
&&&&&&&&Point dest = new Point(source.X, source.Y);
&&&&&&&&//或以下写法
&&&&&&&&//Point dest = new Point()
&&&&&&&&//dest.X = source.X&& &&&&其时，source和dest就是两个互相独立的对象了，两者的修改都不会影响对方。&<font class="Apple-style-span" color="#.&一些需要注意的东西&&&&&&&（<font class="Apple-style-span" color="#）：String字符串对象是引用对象，但是很特殊，它表现的如值对象一样，即对它进行赋值，分割，合并，并不是对原有的字符串进行操作，而是返回一个新的字符串对象。&&&&&&&（<font class="Apple-style-span" color="#）：Array数组对象是引用对象，在进行赋值的时候，实际上返回的是源对象的另一份引用而已；因此如果要对数组对象进行真正的复制（深拷贝），那么需要新建一份数组对象，然后将源数组的值逐一拷贝到目的对象中。
阅读(837) | 评论(0) | 转发(0) |
相关热门文章
给主人留下些什么吧！~~
请登录后评论。请尊重原作者的辛苦劳动，转载请注明出处。http://blog.csdn.net/jslsblog/article/details/
实践是检验真理的唯一标准。下面就让我们在实践中认识copy和mutableCopy的共同点和区别。
1.copy和mutableCopy的实现过程。
想要一个对象能实现copy首先要继承NSCopying的协议，然后实现&#43; (id)copyWithZone:(struct _NSZone *)zone，mutableCopy对应的是NSMutableCopying协议和&#43; (id)mutableCopyWithZone:(struct _NSZone *)zone方法。
不同的对象，在实现copyWithZone：和mutableCopyWithZone：的时候实现方式是不同的，这就导致了不同的对象在调用了copy或者mutableCopy后有的是返回原来的指针，有的是返回一个新的指针。
2.NSString copy举例
NSString *str1 = @&eg&;
NSString *str2 = [str1 copy];
这时候打印retainCount，结果str1和str2的都是-1，说明对于字符串常量没有进行计数，copy的时候没有任何效果，结果等同于NSString *str2 = str1;
同理：NSString *str1 = [[NSString alloc] initWithString:@&12345&];
str1的retainCount = -1；说明这样创建也是常量，alloc没有分配内存。
eg2:不可变变量
NSString *str1 = [NSString stringWithFormat:@&eg&];
NSLog(@&str1 retainCount:%d&,(int)[str1 retainCount]);
NSString *str2 = [str1 copy];
NSLog(@&str1 retainCount:%d&,(int)[str1 retainCount]);
NSLog(@&str2 retainCount:%d&,(int)[str2 retainCount]);
打印的结果是
str1 retainCount:1
str1 retainCount:2
str2 retainCount:2
而且你如果打印str1和str2的地址，你会发现两者的地址也是不同的，并且地址相差的长度为8.当[str1 release]的时候str1和str2的retainCount都变为1.从以上结果可以推测str1和str2指向同一个对象，享有相同的计数&#20540;。这时候的copy = retain。
eg3：可变变量
& & NSMutableString *str1 = [NSMutableString stringWithFormat:@&ss&];
& & NSLog(@&str1 retainCount:%d&,(int)[str1 retainCount]);
& & NSString *str2 = [str1 mutableCopy];//或者使用 NSString *str2 = [str1 copy];
& & NSLog(@&str1 retainCount:%d&,(int)[str1 retainCount]);
& & NSLog(@&str2 retainCount:%d&,(int)[str2 retainCount]);
& & 打印结果：
& & str1 retainCount:1
str1 retainCount:1
str2 retainCount:1
如果[str1 release];是不会影响str2的&#20540;和retainCount。从以上结果可以推断出copy 和mutableCopy等于从新创建一个新的NSString，并且把str1的&#20540;付给str2，str1和str2是完全不同的两个对象。
从以上三个例子说明了不同的对象在不同的情况下对copyWithZone：和mutableCopyWithZone：的实现是不同的，不能一概而论。
浅拷贝就是复制一份指针，而深拷贝就是创建一个新的对象，然后把&#20540;复制过去，原来的对象和新建的对象之后没有任何关系。copy和mutableCopy不能一概的说是浅拷贝还是深拷贝，需要针对不同的实现方法来判断。
和NSString类&#20284;的类还有NSNumber. NSArray和&NSString略有不同。NSArray不论用什么方式创建都会retainCount=1，mutableCopy和copy都会创建新的数组。
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：84980次
积分：1245
积分：1245
排名：千里之外
原创：29篇
转载：38篇
评论：16条
(1)(2)(1)(5)(1)(2)(1)(5)(1)(8)(5)(1)(8)(14)(11)(1)(7)C++&的浅拷贝和深拷贝（结构体）_情不知所起，一往而深_新浪博客
C++&的浅拷贝和深拷贝（结构体）
关于浅拷贝和深拷贝这个问题遇上的次数不多，这次遇上整理一下，先说这样一个问题，关于浅拷贝的问题，先从最简单的说起。
假设存在一个结构体：
struct Student
& & string
&#8203;这样一个最简单的问题
然后执行：
Student stu = {"liming",
& & struct
Student stu2 = {"wanger",
& & stu2 =
cout&&"age is :
"&& stu2.age
cout&&"name is
stu2.name&&endl;
&#8203;这样可以看到的结果是：
age is : 18
name is :liming
说明此时的拷贝是成功的，此时的结构体可以通过“＝”来直接进行赋值操作，但是接下来的问题产生了，假设存在如下的结构体：&#8203;
struct stu
执行下面的程序：
stu s1,s2;
char * str = "rabbit is
& & s1.i =
& & s1.c =
& & s1.p =
& & s2 = s1;
printf("s2 %d, %c, %s\n",
s2.i, s2.c, s1.p);
printf("s1 ptr: %d, s2 ptr : %d\n",
&#8203;产生的结果是这样的：
s2 345, y, rabbit is cute
s1 ptr: 7934, s2 ptr : 7934
可以看到的是S2 确实得到了S1
传递的值，但是第二句的话却说明这样的一个问题，其实S2和S1的指针p都指向一个内存地址，这又说明了什么？
这说明指针的并没有将内容复制一块给新指针来指向，只是让新指针指向原来的那个内存，这样就相当于，指针在这个复制的过程中只是复制了地址，而不是内容。
原理：&#8203;
在拷贝过程中，如果没有自定义拷贝构造函数，系统会提供一个缺省的拷贝构造函数，缺省的拷贝构造函数对于基本类型的成员变量，按字节复制，对于类类型成员变量，调用其相应类型的拷贝构造函数。但是注意缺省的构造函数却是这样的：缺省拷贝构造函数在拷贝过程中是按字节复制的，对于指针型成员变量只复制指针本身，而不复制指针所指向的目标--浅拷贝。
这就是产生问题的原因了，浅拷贝出现了。。。
用下图来解释这个问题：
在进行对象复制后，事实上s1、s2里的成员指针p都指向了一块内存空间（即内存空间共享了），在s1析构时，delete了成员指针p所指向的内存空间，而s2析构时同样指向（此时已变成野指针）并且要释放这片已经被s1析构函数释放的内存空间，这就让同样一片内存空间出现了“double
，从而出错。而浅拷贝还存在着一个问题，因为一片空间被两个不同的子对象共享了，只要其中的一个子对象改变了其中的值，那另一个对象的值也跟着改变了。
&&&&&&&为了实现深拷贝，往往需要自己定义拷贝构造函数，在源代码里，我们加入自定义的拷贝构造函数如下：
在结构体中加入自己的拷贝构造函数：
struct stu
operator=(stu&
& i = stuTmp.i;
& c = stuTmp.c;
char(strlen(stuTmp.p) +
& strcpy(p,
stuTmp.p);
& return *this;
相当于重载operator＝方法，这样还是运行，产生的结果就是这样的：
s2 345, y, rabbit is cute
s1 ptr: 7910, s2 ptr : 1050000
此时s1和s2中的指针p指向了不同的地址，可以打印一下此时这两个指针的内容是否一样，加入一下代码：
printf("s1 ptr: %s, s2 ptr :
%s\n ", s1.p,
s2.p);&#8203;&#8203;
产生的结果是：s1 ptr:
rabbit is cute, s2 ptr : rabbit is cute&#8203;
此时s1和s2中的p指针地址不同，但是指向的内容一致，所以这拷贝成功。&#8203;
其实类的结构和上面的结构体是类似的，其实可以将结构体看成一个类来处理，结构体也可有自己的构造、析构、重载运算符河函数，可以简单的认为结构体是类的一种形式。
拷贝有两种：深拷贝，浅拷贝&
当出现类的等号赋值时，会调用拷贝函数
在未定义显示拷贝构造函数的情况下，系统会调用默认的拷贝函数——即浅拷贝，它能够完成成员的一一复制。当数据成员中没有指针时，浅拷贝是可行的。
但当数据成员中有指针时，如果采用简单的浅拷贝，则两类中的两个指针将指向同一个地址，当对象快结束时，会调用两次析构函数，而导致指针悬挂现象。
所以，这时，必须采用深拷贝。 深拷贝与浅拷贝的区别就在于深拷贝会在堆内存中另外申请空间来储存数据，从而也就解决了指针悬挂的问题。
简而言之，当数据成员中有指针时，必须要用深拷贝。&#8203;
&#8203;建议：
我们在定义类或者结构体，这些结构的时候，最后都重写拷贝构造函数，避免浅拷贝这类不易发现但后果严重的错误产生。&#8203;
情不知所起，一往而深
博客等级：
博客积分：0
博客访问：12,971
关注人气：0
荣誉徽章：}