• C++:拷贝构造函数,深拷贝,浅拷贝


    一.什么是拷贝构造函数? 

            同一个类的对象在内存中有完全相同的结构,如果作为一个整体进行复制(拷贝)是完全可行的。这个拷贝过程只需要拷贝数据成员,而函数成员是共用的(只有一份拷贝)。在建立对象时可用同一类的另一个对象来初始化该对象的存储空间,这时所用的构造函数称为拷贝构造函数。拷贝构造函数也是构造函数的一种,只是与构造函数的形参不同
    示例:

    1. //拷贝构造函数
    2. class Complex
    3. {
    4. private:
    5. int real;
    6. int image;
    7. public:
    8. Complex():real(0), image(0) //缺省的构造函数
    9. {
    10. cout << "Create Complex:()" << endl;
    11. }
    12. Complex(int r, int i) :real(r), image(i) //带参数的构造函数
    13. {
    14. cout << "Create Complex(int,int) " << endl;
    15. }
    16. ~Complex()
    17. {
    18. cout << "Destroy Complex: " << endl;
    19. }
    20. //不加引用&,则会变为无穷递归的形式,设置成值类型,必须要构建对象,而设计成引用,只是当前对象的别名
    21. Complex(const Complex& com) :real(com.real), image(com.image) //拷贝构造函数 形参必须是引用
    22. { //为了防止拷贝构造过程中改变cb对象 加const
    23. //real = com.real;
    24. //Complex cc(cb); -> Complex(&cc,cb);
    25. cout << "Copy Create Complex(const Complex&)" << this << endl;
    26. }
    27. };
    28. void fun(Complex cs)
    29. {
    30. }
    31. int main()
    32. {
    33. Complex ca;
    34. Complex cb(1,2);//用c1初始化c2
    35. Complex cc(cb); //用一个对象初始化另一个对象时 调动拷贝构造
    36. fun(ca);
    37. return 0;
    38. }

     调试结果:

    运行结果:

     

    二.什么情况下使用拷贝构造函数?

    一般来说有以下三种情况:

    1. 用旧对象去初始化新对象
    2. 值传递—参数是类类型的值类型,从实参传递给形参的过程,是用实参去构造形参
    3. 函数返回值是值类型–用局部对象去构造临时对象调用拷贝构造
    1. class Person
    2. {
    3. public:
    4. //无参(默认)构造函数
    5. Person() {
    6. cout << "Person的默认构造函数调用!" << endl;
    7. }
    8. Person(int age) {
    9. cout << "Person有参构造函数调用!" << endl;
    10. m_Age = age;
    11. }
    12. Person(const Person& p) {
    13. cout << "Person拷贝构造函数调用!" << endl;
    14. m_Age = p.m_Age;
    15. }
    16. ~Person() {
    17. cout << "Person的析构函数调用!" << endl;
    18. }
    19. public:
    20. int m_Age;
    21. };
    22. //1 使用一个已经创建完毕的对象来初始化一个新对象
    23. void test01()
    24. {
    25. Person p1(20); //创建一个新对象p1
    26. Person p2(p1); //拷贝 把p1的全部拷贝过来
    27. cout << "P2的年龄为: " <
    28. }
    29. //2 值传递的方式给函数参数传值
    30. void doWork(Person p)
    31. {
    32. //值传递相当于Person p = p拷贝构造函数隐式写法
    33. }
    34. void test02()
    35. {
    36. Person p;
    37. doWork(p);
    38. }
    39. //3 以值方式返回局部对象
    40. Person doWork2()
    41. {
    42. Person p1;
    43. cout << (int*)&p1 << endl;
    44. return p1;
    45. }
    46. void test03()
    47. {
    48. Person p = doWork2();
    49. }
    50. int main()
    51. {
    52. test01();
    53. test02();
    54. test03();
    55. return 0;
    56. }

     

    三.使用拷贝构造函数需要注意什么?

    1. 拷贝构造函数是构造函数的一个重载形式
    2. 拷贝构造函数的参数只有一个且必须使用引用传参,使用传值方式会引发无穷递归调用。
    3. 若未显示定义,系统生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储按字节序完成拷贝,称为:位拷贝

    练习1:写拷贝构造函数

    1. //写拷贝构造函数
    2. class CGoods
    3. {
    4. private:
    5. enum { LEN=20 }; //枚举型是常量
    6. char Name[LEN]; //20
    7. int Amount;
    8. float Price;
    9. float Total_value; //32
    10. public:
    11. CGoods() :Name{}, Amount{}, Price{}, Total_value{} //无参构造函数
    12. {
    13. }
    14. CGoods(const char* name, int amount, float price)
    15. {
    16. strcpy_s(Name, LEN, name);
    17. Amount = amount;
    18. Price = price;
    19. Total_value = Amount * Price;
    20. }
    21. };
    22. int main()
    23. {
    24. CGoods book("C++", 10, 128.0f);
    25. CGoods bx(book); //没有写 系统提供一个缺省的拷贝构造函数 按位拷贝
    26. return 0;
    27. }

    运行结果: 

    写入拷贝构造函数:

    1. //写拷贝构造函数
    2. class CGoods
    3. {
    4. private:
    5. enum { LEN=20 }; //枚举型是常量
    6. char Name[LEN]; //20
    7. int Amount;
    8. float Price;
    9. float Total_value; //32
    10. public:
    11. CGoods() :Name{}, Amount{}, Price{}, Total_value{} //无参构造函数
    12. {
    13. }
    14. CGoods(const char* name, int amount, float price)
    15. {
    16. strcpy_s(Name, LEN, name);
    17. Amount = amount;
    18. Price = price;
    19. Total_value = Amount * Price;
    20. }
    21. CGoods(const CGoods& c) //浅拷贝
    22. {
    23. strcpy_s(Name, LEN, c.Name);
    24. Amount = c.Amount;
    25. Price = c.Price;
    26. Total_value = c.Total_value;
    27. cout << "Copy CGoods(const CGoods&): " << this << endl;
    28. }
    29. };
    30. int main()
    31. {
    32. CGoods book("C++", 10, 128.0f);
    33. CGoods bx(book); //没有写 系统提供一个缺省的拷贝构造函数 按位拷贝
    34. return 0;
    35. }

     

    练习2:写拷贝构造函数 

    当函数的返回值是类对象
           当函数的返回值是类对象,函数执行完成返回调用者时使用。理由也是要建立一个临时对象中,再返回调用者。
           因为局部对象在离开建立它的函数时就消亡了,不可能在返回调用函数后继续生存,所以在处理这种情况时,编译系统会在调用函数的表达式中创建一个无名临时对象,该临时对象的生存周期只在函数调用处的表达式中。
            所谓return 对象,实际上是调用拷贝构造函数把该对象的值拷入临时对象空间。如果返回的是变量,处理过程类似,只是不调用构造函数。

    四、深拷贝和浅拷贝

           拷贝构造函数是一个重载的构造函数,由编写类的程序员提供。每当对象被复制时,编译器都将调用复制构造函数。

    先写一个普通构造函数,析构函数:

    1. class Person {
    2. public:
    3. Person()
    4. {
    5. cout << "无参构造函数!" << endl;
    6. }
    7. //有参构造函数
    8. Person(int age)
    9. {
    10. m_Age = age;
    11. cout << "有参构造函数!" << endl;
    12. }
    13. //析构函数
    14. ~Person()
    15. {
    16. cout << "析构函数!" << endl;
    17. }
    18. int m_Age; //年龄
    19. };
    20. void test01()
    21. {
    22. Person p1(18);
    23. cout << "p1的年龄: " << p1.m_Age<
    24. }
    25. int main()
    26. {
    27. test01();
    28. }

    运行结果:

    浅拷贝:简单的赋值拷贝操作
    深拷贝:在堆区重新申请空间,进行拷贝操作
    1. #include
    2. using namespace std;
    3. class Person {
    4. public:
    5. Person()
    6. {
    7. cout << "无参构造函数!" << endl;
    8. }
    9. //有参构造函数
    10. Person(int age, int height)
    11. {
    12. m_Age = age;
    13. m_Height = new int(height);
    14. cout << "有参构造函数!" << endl;
    15. }
    16. //自己实现拷贝构造函数,解决浅拷贝带来的问题
    17. Person(const Person& p)
    18. {
    19. cout<< "拷贝构造函数!" << endl;
    20. //如果不利用深拷贝在堆区创建新内存,会导致浅拷贝带来的重复释放堆区问题
    21. m_Age = p.m_Age;
    22. // m_height = new int(*p.m_height); 编译器默认实现就是这行代码
    23. //深拷贝操作
    24. m_Height=new int(*p.m_Height);
    25. }
    26. //析构函数
    27. ~Person()
    28. {
    29. //析构代码,将堆区开辟的数据做释放操作
    30. if (m_Height != NULL)
    31. {
    32. delete m_Height;
    33. m_Height = NULL;
    34. }
    35. cout << "析构函数!" << endl;
    36. }
    37. int m_Age; //年龄
    38. int* m_Height; //身高 开辟到堆区
    39. };
    40. void test01()
    41. {
    42. Person p1(18,160);
    43. cout << "p1的年龄: " << p1.m_Age<< " 身高: " << *p1.m_Height << endl;
    44. Person p2(p1);//调用拷贝构造函数 编译器做了一个浅拷贝的工作
    45. cout << "p2的年龄: " << p2.m_Age << " 身高: " << *p2.m_Height << endl;
    46. }
    47. int main()
    48. {
    49. test01();
    50. }

    运行结果:

    如果属性有在堆区开辟的,一定要自己提供拷贝构造函数,防止浅拷贝带来的问题
  • 相关阅读:
    oracle sql monitor简单使用说明
    简单个人网页设计作业 静态HTML个人主题网页作业 DW个人网站模板下载 大学生简单个人网页作品代码 个人网页制作 学生个人网页Dreamweaver设计作业
    手机注册.
    一起Talk Android吧(第四百一十九回:让时钟走起来)
    PyTorch学习笔记之基础函数篇(八)
    【软件测试】理论知识基础第一章
    MySql ocp认证之MySql安装(一)
    getBytes方法
    Fourier分析导论——第5章——实数据R上的Fourier变换(E.M. Stein & R. Shakarchi)
    C++入门,详解类和对象(1)
  • 原文地址:https://blog.csdn.net/hmh520i/article/details/134511824