C++ 类的深拷贝与浅拷贝||深拷贝通过重载拷贝构造函数与重载赋值运算符实现

http://blog.csdn.net/wangshihui512/article/details/9842225

在面向对象程序设计中，对象间的相互拷贝和赋值是经常进行的操作。
如果对象在申明的同时马上进行的初始化操作，则称之为拷贝运算。例如：

class1 A("Time"); 

class1 B=A;

此时其实际调用的是B(A)，拷贝构造函数。
如果对象在申明之后，在进行的赋值运算，我们称之为赋值运算。例如：

class1 A("Time"); 

class1 B;

B=A;
此时实际调用的类的缺省赋值函数B.operator=(A);
不管是拷贝构造函数还是赋值运算，其都有缺省的定义。也就是说，即使我们不overload这两种operation,仍然可以运行。一般，如果需要手动编写析构函数的类，都需要overload 拷贝构造函数和赋值运算符。
重载（overload)赋值运算符 
对于对象的域在heap上分配内存的情况，我们必须重载赋值运算符。当对象间进行拷贝的时候，我们必须让不同对象的成员域指向其不同的heap地址--如果成员域属于heap的话。
因此，重载赋值运算符后的代码如下：

[cpp] view plaincopy
print?
  1. class A  
  2. {  
  3. public:  
  4.     A()  
  5.     {  
  6.     }  
  7.     A(int id,char *t_name)  
  8.     {  
  9.         _id=id;  
  10.         name=new char[strlen(t_name)+1];  
  11.         strcpy(name,t_name);  
  12.     }  
  13.       
  14.     A& operator =(A& a)//注意：此处一定要返回对象的引用，否则返回后其值立即消失！  
  15.     {  
  16.         if(name!=NULL)  
  17.                 delete name;  
  18.         this->_id=a._id;  
  19.         name=new char[strlen(a.name)+1];  
  20.         strcpy(name,a.name);  
  21.         return *this;  
  22.     }  
  23.   
  24.     ~A()  
  25.     {  
  26.         cout<<"~destructor"<<endl;  
  27.         delete name;  
  28.     }  
  29.   
  30.     int _id;  
  31.     char *name;  
  32. };  
  33.   
  34. int main()  
  35. {  
  36.  A a(1,"http://blog.csdn.net/shihui512");  
  37.  A b;  
  38.  b=a;  
  39. }  


在对象a,b退出相应的作用域，其调用相应的析构函数，然后释放分别属于不同heap空间的内存，程序正常结束。

类的深拷贝函数的重载
[cpp] view plaincopy
print?
  1.  public class A  
  2. {  
  3.     public:  
  4.         ...  
  5.         A(A &a);//重载拷贝函数  
  6.         A& operator=(A &b);//重载赋值函数  
  7.         //或者 这样重载赋值运算符 void operator=(A &a);即不返回任何值。如果这样的话，将不能链式赋值 ，例如a=b=c  
  8.     private:  
  9.         int _id;  
  10.         char *username;  
  11. }  
  12.   
  13. A::A(A &a)  
  14. {  
  15.     _id=a._id;  
  16.     username=new char[strlen(a.username)+1];  
  17.     if(username!=NULL)  
  18.         strcpy(username,a.usernam);  
  19. }  
  20.   
  21. A& A::operaton=(A &a)  
  22. {  
  23.         if(this==&a)//  优化操作。  
  24.             return *this;  
  25.         if(username!=NULL)  
  26.             delete username;  
  27.         _id=a._id;  
  28.         username=new char[strlen(a.username)+1];  
  29.         if(username!=NULL)  
  30.             strcpy(username,a.usernam);  
  31.         return *this;      
  32. }  

赋值运算符和拷贝函数很相似。只不过赋值函数最好有返回值（进行链式赋值），返回也最好是对象的引用， 而拷贝函数不需要返回任何。同时，赋值函数首先要释放掉对象自身的堆空间（如果需要的话），然后进行其他的operation.而拷贝函数不需要如此，因为对象此时还没有分配堆空间。

note1:
不要按值向函数传递对象。如果对象有内部指针指向动态分配的堆内存，丝毫不要考虑把对象按值传递给函数，要按引用传递。并记住：若函数不能改变参数对象的状态和目标对象的状态，则要使用const修饰符
note2:问题：
对于类的成员需要动态申请堆空间的类的对象，都最好要overload其赋值函数和拷贝函数。拷贝构造函数是没有任何返回类型的，这点毋庸置疑。 而赋值函数可以返回多种类型，例如以上讲的void,类本身，以及类的引用。
问，这几种赋值函数的返回各有什么异同？
答：
1 如果赋值函数返回的是void ，我们知道，其唯一一点需要注意的是，其不支持链式赋值运算，即a=b=c这样是不允许的！
2 对于返回的是类对象本身，还是类对象的引用，其有着本质的区别！
第一：如果其返回的是类对象本身。
A operator =(A& a)
{
    if(name!=NULL)
    delete name;
    this->_id=a._id;
    int len=strlen(a.name);
    name=new char[len+1];
    strcpy(name,a.name);
    return *this;

}

[cpp] view plaincopy
print?
  1. A operator =(A& a)  
  2. {  
  3.     if(name!=NULL)  
  4.     delete name;  
  5.     this->_id=a._id;  
  6.     int len=strlen(a.name);  
  7.     name=new char[len+1];  
  8.     strcpy(name,a.name);  
  9.     return *this;  
  10. }  

其过程是这样的：
class1 A("Time");
class1 B; 
B=A;
其所有的过程如下：
1 释放对象原来的堆资源
2 重新申请堆空间
3 拷贝源的值到对象的堆空间的值
4 创建临时对象（调用临时对象拷贝构造函数），将临时对象返回
5. 临时对象结束，调用临时对象析构函数，释放临时对象堆内存
但是，在这些步骤里面，如果第4步，我们没有overload 拷贝函数，也就是没有进行深拷贝。那么在进行第5步释放临时对象的heap 空间时，将释放掉的是和目标对象同一块的heap空间。这样当目标对象B作用域结束调用析构函数时，就会产生错误！！因此，如果赋值运算符返回的是类对象本身，那么一定要overload 类的拷贝构造函数（进行深拷贝）！
第二：如果赋值运算符返回的是对象的引用，
A& operator =(A& a)
{
    if(name!=NULL)
    delete name;
    this->_id=a._id;
    int len=strlen(a.name);
    name=new char[len+1];
    strcpy(name,a.name);
    return *this;
}
那么其过程如下：
1 释放掉原来对象所占有的堆空间
2 申请一块新的堆内存
3 将源对象的堆内存的值copy给新的堆内存
4 返回源对象的引用
5 结束。

因此，如果赋值运算符返回的是对象引用，那么其不会调用类的拷贝构造函数，这是问题的关键所在！！

一个类对象拷贝的简单例子。 

[cpp] view plaincopy
print?
  1. #include <iostream>  
  2. using namespace std;  
  3. class CExample  
  4. {  
  5. private:  
  6. 　int a;  
  7. public:  
  8. 　CExample(int b){ a=b;}  
  9. 　void Show ()  
  10. 　{  
  11.     cout<<a<<endl;  
  12.    }  
  13. };  
  14.   
  15. int main()  
  16. {  
  17. 　CExample A(100);  
  18. 　CExample B=A;  
  19. 　B.Show ();  
  20. 　return 0;  
  21. }   

运行程序，屏幕输出100。从以上代码的运行结果可以看出，系统为对象B分配了内存并完成了与对象A的复制过程。就类对象而言，相同类型的类对象是通过拷贝构造函数来完成整个复制过程的。下面举例说明拷贝构造函数的工作过程。


[cpp] view plaincopy
print?
  1. #include <iostream>  
  2. using namespace std;  
  3.   
  4. class CExample  
  5. {  
  6.    private:  
  7.    int a;  
  8.    public:  
  9.    CExample(int b){ a=b;}  
  10.    CExample(const CExample& C){a=C.a;}  
  11.    void Show ()  
  12.    {  
  13.     cout<<a<<endl;  
  14.    }  
  15. };  
  16.   
  17. int main()  
  18. {  
  19.   CExample A(100);  
  20.   CExample B=A;  
  21.   B.Show ();  
  22.   return 0;  
  23. }  


CExample(const CExample& C)就是我们自定义的拷贝构造函数。可见，拷贝构造函数是一种特殊的构造函数，函数的名称必须和类名称一致，它的唯一的一个参数是本类型的一个引用变量，该参数是const类型，不可变的。例如：类X的拷贝构造函数的形式为X(X& x)。

当用一个已初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候，拷贝构造函数就会被自动调用。也就是说，当类的对象需要拷贝时，拷贝构造函数将会被调用。以下情况都会调用拷贝构造函数：
一个对象以值传递的方式传入函数体 
一个对象以值传递的方式从函数返回 
一个对象需要通过另外一个对象进行初始化。 

如果在类中没有显式地声明一个拷贝构造函数，那么，编译器将会自动生成一个默认的拷贝构造函数，该构造函数完成对象之间的位拷贝。位拷贝又称浅拷贝。 
自定义拷贝构造函数是一种良好的编程风格，它可以阻止编译器形成默认的拷贝构造函数，提高源码效率。

浅拷贝和深拷贝 
在某些状况下，类内成员变量需要动态开辟堆内存，如果实行位拷贝，也就是把对象里的值完全复制给另一个对象，如A=B。这时，如果B中有一个成员变量指针已经申请了内存，那A中的那个成员变量也指向同一块内存。这就出现了问题：当B把内存释放了（如：析构），这时A内的指针就是野指针了，出现运行错误。 深拷贝和浅拷贝可以简单理解为：如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝，反之，没有重新分配资源，就是浅拷贝。下面举个深拷贝的例子。

[cpp] view plaincopy
print?
  1. #include <iostream>  
  2. using namespace std;  
  3. class CA  
  4. {  
  5. 　public:  
  6. 　　CA(int b,char* cstr)  
  7. 　　{  
  8. 　　　a=b;  
  9. 　　　str=new char[b];  
  10. 　　　strcpy(str,cstr);  
  11. 　　}  
  12. 　　CA(const CA& C)  
  13. 　　{  
  14. 　　　a=C.a;  
  15. 　　　str=new char[a]; //深拷贝  
  16. 　　　if(str!=0)  
  17. 　　　　strcpy(str,C.str);  
  18. 　　}  
  19. 　　void Show()  
  20. 　　{  
  21. 　　　cout<<str<<endl;  
  22. 　　}  
  23. 　　~CA()  
  24. 　　{  
  25. 　　　delete str;  
  26. 　　}  
  27. 　private:  
  28. 　　int a;  
  29. 　　char *str;  
  30. };  
  31.   
  32. int main()  
  33. {  
  34. 　CA A(10,"Hello!");  
  35. 　CA B=A;  
  36. 　B.Show();  
  37. 　return 0;  
  38. }   

深拷贝和浅拷贝的定义可以简单理解成：如果一个类拥有资源(堆，或者是其它系统资源)，当这个类的对象发生复制过程的时候，这个过程就可以叫做深拷贝，反之对象存在资源，但复制过程并未复制资源的情况视为浅拷贝。
浅拷贝资源后在释放资源的时候会产生资源归属不清的情况导致程序运行出错。 
Test(Test &c_t)是自定义的拷贝构造函数，拷贝构造函数的名称必须与类名称一致，函数的形式参数是本类型的一个引用变量,且必须是引用。 
当用一个已经初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候，拷贝构造函数就会被自动调用，如果你没有自定义拷贝构造函数的时候，系统将会提供给一个默认的拷贝构造函数来完成这个过程。

在某些状况下，类体内的成员是需要开辟动态开辟堆 内存的,如果不自定义拷贝构造函数而让系统自己处理，那么就会导致堆内存的所属权产生混乱，例如，已经开辟的一端堆地址原来是属于对象a的，由于复制过程发生，b对象取得是a已经开辟的堆地址，一旦程序产生析构，释放堆的时候，计算机是不可能清楚这段地址是真正属于谁的，当连续发生两次析构的时候 ，就出现了运行错误。拷贝和浅拷贝的定义可以简单理解成：如果一个类拥有资源(堆，或者是其它系统资源)，当这个类的对象发生复制过程的时候，这个过程就可以叫做深拷贝，反之对象存在资源但复制过程并未复制资源的情况视为浅拷贝。
浅拷贝资源后在释放资源的时候会产生资源归属不清的情况导致程序运行出错,这点尤其需要注意！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/384244.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

C++ 类的const成员函数

C++ 类的const成员函数

http://blog.csdn.net/wangshihui512/article/details/9823739 我们定义的类的成员函数中&#xff0c;常常有一些成员函数不改变类的数据成员&#xff0c;也就是说&#xff0c;这些函数是"只读"函数&#xff0c;而有一些函数要修改类数据成员的值。如果把不改变数据…
阅读更多...
用servlet校验密码2

用servlet校验密码2

js //创建Ajax对象&#xff0c;不同浏览器有不同的创建方法&#xff0c;其实本函数就是一个简单的new语句而已。 function createXMLHttpRequest() {var XMLHttpRequest1;if (window.XMLHttpRequest) {XMLHttpRequest_test new XMLHttpRequest();} else if (window.ActiveXOb…
阅读更多...
【笔试】：编程实现C++string 类成员函数

【笔试】：编程实现C++string 类成员函数

http://blog.csdn.net/wangshihui512/article/details/9792309 已知String类声明如下&#xff1a; [cpp] view plaincopy print?class String { public: String(const char *str NULL); // 通用构造函数 String(const String &another); // 拷贝…
阅读更多...
Qt中字符串之间的转换

Qt中字符串之间的转换

//QString -> C string -> char * str.ToStdString().data(); //先转换为C的标准编码//QString -> QByteArray QString buf "123456"; QByteArray a buf.toUtf8();//中文 a buf.toLocal8Bit(); //转换为本地编码 //QByteArray -> char * char *b …
阅读更多...
（C语言版）栈和队列（一）——实现链式栈和链式队列的基本操作以及遇到的问题

（C语言版）栈和队列（一）——实现链式栈和链式队列的基本操作以及遇到的问题

http://blog.csdn.net/fisherwan/article/details/20055179 首先要感谢这位大牛的一篇博客&#xff0c;地址如下&#xff1a;http://blog.csdn.net/hguisu/article/details/7674195 当然还有网上一些其他的资料&#xff0c;今天自己写了一下链式栈和链式队列的程序。其中在释放…
阅读更多...
Cookie的使用

Cookie的使用

ookie简介 1. 定义 cookie是由服务器发送给客户端&#xff08;浏览器&#xff09;的小量信息。 2. 作用 cookie是键值对形式存储的少量信息&#xff0c;那它有什么作用呢&#xff1f; 我们知道&#xff0c;平时上网时都是使用无状态的HTTP协议传输出数据&#xff0c;这意味着客…
阅读更多...
循环链表解决约瑟夫问题（简化版）

循环链表解决约瑟夫问题（简化版）

http://blog.csdn.net/jw903/article/details/38965477 约瑟夫环是一个经典的数学的应用问题&#xff1a;已知N个人&#xff08;以编号1&#xff0c;2&#xff0c;3...N分别表示&#xff09;围坐在一张圆桌周围。从编号为1的人开始报数&#xff0c;数到M的那个人出列&#xff1…
阅读更多...
Linux平台上SQLite数据库教程（一）——终端使用篇

Linux平台上SQLite数据库教程（一）——终端使用篇

http://blog.csdn.net/u011192270/article/details/48031763 SQLite是一款轻型的数据库&#xff0c;它的设计目标是嵌入式的&#xff0c;而且目前已经在很多嵌入式产品中使用了它&#xff0c;它占用资源非常的低&#xff0c;可能只需要几百K的内存就够了。能够支持Windows/Lin…
阅读更多...
多路IO转接服务器 epoll

多路IO转接服务器 epoll

创建一个epoll句柄&#xff0c;参数size用来告诉内核监听的文件描述符的个数&#xff0c;跟内存大小有关。 #include <sys/epoll.h> int epoll_create(int size)　　 size&#xff1a;监听数目 通过创建一个size大小的红黑数来实现epoll句柄&#xff0c;返回epfd是该…
阅读更多...
Linux平台上SQLite数据库教程（二）——C语言API介绍

Linux平台上SQLite数据库教程（二）——C语言API介绍

http://blog.csdn.net/u011192270/article/details/48086961 前言&#xff1a;本文将介绍几个基本的SQLite3数据库的C语言API接口&#xff0c;主要用到两个文件&#xff1a;sqlite3.c、sqlite3.h。源码地址&#xff1a;https://github.com/AnSwErYWJ/SQLite。 打开数据库 1.原型…
阅读更多...
epoll非阻塞IO

epoll非阻塞IO

设置connfd套接字为非阻塞 flag fcntl(connfd, F_GETFL); flag | O_NONBLOCK; fcntl(connfd, F_SETFL, flag); 转载于:https://www.cnblogs.com/lr1402585172/p/10758740.html
阅读更多...
小白创建网站的曲折之路

小白创建网站的曲折之路

小白创建网站的曲折之路 在虚拟机上创建网站 顾名思义&#xff0c;首先要有一个虚拟机。在网上百度一下后&#xff0c;我发现大家都在说使用一种叫做VMware Workstation的软件进行虚拟机的构建 在这位好心人的帮助下我找到了Vmware Workstation的下载资源&#xff0c;并成功下…
阅读更多...
Ubuntu 14.04数据库服务器--mysql的安装和配置

Ubuntu 14.04数据库服务器--mysql的安装和配置

https://jingyan.baidu.com/article/425e69e6bbc6c7be14fc1640.html mysql是Oracle公司的一种开放源代码的关系型数据库管理系统&#xff0c;被广泛应用于各中小网站&#xff0c;是一种跨平台的数据库管理系统&#xff0c;现在介绍一下如何在Ubuntu 14.04上安装和配置mysql 工具…
阅读更多...
javavbean

javavbean

一、什么是javabeanJavaBean是一个遵循特定写法的Java类&#xff0c;它通常具有如下特点&#xff1a;这个Java类必须具有一个无参的构造函数属性必须私有化。私有化的属性必须通过public类型的方法暴露给其它程序&#xff0c;并且方法的命名也必须遵守一定的命名规范。JavaBean…
阅读更多...
Centos7下搭建LAMP环境，安装wordpress（不会生产博客，只是一名博客搬运工）(菜鸟)

Centos7下搭建LAMP环境，安装wordpress（不会生产博客，只是一名博客搬运工）(菜鸟)

1.搭建MySQL数据库 安装MariaDB yum install mariadb-server -y 启动MySQL服务 emctl start mariadb #启动服务 emtcl enable marriadb#设置开机服务 设置MySQL账户和root密码 mysqladmin -u root password ******* 2.安装Apache服务 安装Apache yum install httpd -y 启动A…
阅读更多...
（C语言版）栈和队列（二）——实现顺序存储栈和顺序存储队列的相关操作

（C语言版）栈和队列（二）——实现顺序存储栈和顺序存储队列的相关操作

http://blog.csdn.net/fisherwan/article/details/21479649 栈和队列都有两种实现方式&#xff0c;一种在之前已经写过了&#xff0c;是链式存储形式&#xff0c;另一种是顺序存储形式。也就是这里所写的用数组的形式实现&#xff0c;和链式存储形式相比&#xff0c;有几个不同…
阅读更多...
算法学习——贪心篇

算法学习——贪心篇

贪心选择是指应用同一规则&#xff0c;将原问题变为一个相似但是规模更小的问题&#xff0c;而后的每一步都是当前看起来最佳的选择&#xff0c;且这种选择只依赖于已做出的选择&#xff0c;不依赖于未作出的选择。 贪心算法说起来容易&#xff0c;操作起来却经常有点玄学。&am…
阅读更多...
使用基本MVC2模式创建新闻网站

使用基本MVC2模式创建新闻网站

转载于:https://www.cnblogs.com/lr1402585172/p/10885084.html
阅读更多...
栈（Stack），轻松解决数制转换和括号匹配问题！

栈（Stack），轻松解决数制转换和括号匹配问题！

http://data.biancheng.net/view/9.html 栈&#xff0c;线性表的一种特殊的存储结构。与学习过的线性表的不同之处在于栈只能从表的固定一端对数据进行插入和删除操作&#xff0c;另一端是封死的。 图1 栈结构示意图由于栈只有一边开口存取数据&#xff0c;称开口的那一端为“…
阅读更多...
第一章 TCP/IP协议族

第一章 TCP/IP协议族

一、协议族体系结构 TCP/IP协议族分为四层协议系统&#xff0c;自底向下分别为数据链路层、网络层、传输层、应用层。 数据链路层常用ARP&#xff08;地址解析协议&#xff09;和RARP&#xff08;逆地址解析协议&#xff09;。在网络层使用IP寻址&#xff0c;而在数据链路层使用…
阅读更多...
最新文章

Copyright @ 2022~2023