c# 拷贝结构体_拷贝构造

特殊构造函数

类型转换构造

用从不同类型的对象来构造对象

Complex(double real); //用实数来构造复数类

拷贝构造

用相同类型的对象来构造对象

Complex(Complex const&that); //用另一个复数来构造复数

注意：如果一个类没有定义拷贝构造函数，那么编译器会提供一个默认拷贝构造函数，默认是public

类型转换构造和拷贝构造示例

定义一个复数类Complex

 //Complex.h
 #pragma once
 #include<iostream>
 using namespace std;
 class Complex
 {
     double m_real;  //实部
     double m_vir;   //虚部
 public:
     Complex();  //无参构造
     /*explicit*/ Complex(double real);//类型转换构造 explicit 防止类型隐式转换
 ​
     //不提供拷贝构造函数  编译器提供一个默认的拷贝构造函数
     Complex(Complex const&that);    //拷贝构造
     void printf()const;
 };

实现复数类Complex

 //Complex.cpp
 #include "Complex.h"
 Complex::Complex()
 {
     m_real = 0;
     m_vir = 0;
     cout << "无参构造" << endl;
 }
 Complex::Complex(double real)
 {
     m_real = real;
     m_vir = 0;
     cout << "类型转换构造" << endl;
 }
 Complex::Complex(Complex const & that)
 {
     this->m_real = that.m_real;
     this->m_vir = that.m_vir;
     cout << "拷贝构造" << endl;
 }
 void Complex::printf() const
 {
     cout << m_real << "+" << m_vir << "i" << endl;
 }

使用这个类

 //main.c
 #include"Complex.h"
 int main()
 {
     /***无参构造***/
     Complex var;
     var.printf();
     /***类型转换构造***/
     Complex var_1 = 5;  //隐式将int 换成 Complex 因为Complex提供了单参构造  加上 explicit 防止类型隐式转换
     var_1.printf();
     /***拷贝构造***/
     Complex var_3(var_1);
     Complex var_2 = var_1;
     var_2.printf();
     /***堆区拷贝构造***/
     Complex* var_4 = new Complex(var_1);
     delete var_4;
     cin.get();
     return 0;
 }
 //打印结果
 无参构造
 0+0i
 类型转换构造
 5+0i
 拷贝构造
 拷贝构造
 5+0i
 拷贝构造

explicit

防止类型隐式转换

深拷贝和浅拷贝

浅拷贝----复制地址

对内存地址的复制，让目标指针和源指针指向同块内存
通过其中一个指针去释放内存，其他指向改内存的指针会成为野指针

深拷贝----复制内存

对拷贝对象的内存进行复制l拷贝结束之后，两个对象存的值相同，内存地址不同
l两个对象互不影响，互不干涉

何时需要自定义拷贝构造函数

如果类带有指针变量，并有动态内存分配，则它必须自定义一个拷贝构造函数。

深浅拷贝示例程序

定义一个男朋友类和一个游戏结构体

 //BoyFriend.h
 #pragma once
 #include<iostream>
 #include<string>
 using namespace std;
 struct game //游戏类
 {
     char m_name[10];    //游戏昵称
     int m_grade;        //等级
     game(char* name="",int grade=0)
     {
         strcpy(m_name, name);
         m_grade = grade;
     }
 };
 class BoyFriend
 {
     string m_name;
     game* m_account;    //一个game类型指针
 public:
     BoyFriend(string name);
     BoyFriend(const BoyFriend& that);
     void introduce() const;
     ~BoyFriend();
 };

实现男朋友类

 //BoyFriend.cpp
 #include "BoyFriend.h"
 BoyFriend::BoyFriend(string name)
 {
     m_name = name;
     m_account = new game("马化腾",201);
 }
 BoyFriend::BoyFriend(const BoyFriend & that)
 {
     this->m_name = that.m_name;
 #if 0
     //浅拷贝     拷贝地址  系统默认的拷贝构造没有权限分配堆区内存 默认构造函数是浅拷贝
     this->m_account = that.m_account;
 #endif
 #if 1
     //深拷贝     拷贝内存  类带有指针变量，并有动态内存分配，则它必须有一个拷贝构造函数
     //1.分配新资源
     this->m_account = new game;
     //2.拷贝新资源
     memcpy(this->m_account,  //拷贝的目标内存首地址
         that.m_account,      //拷贝的源内存首地址
         sizeof(game));       //拷贝字节大小
 #endif
     cout << "拷贝构造" << endl;
 }
 void BoyFriend::introduce() const
 {
     cout << "我叫" << m_name <<",游戏账号昵称是"<<m_account->m_name<< ",游戏账号等级是" << m_account->m_grade << endl;
 }
 BoyFriend::~BoyFriend()
 {
     if (m_account)
     {
         delete m_account;
         m_account = NULL;
     }
     cout << "析构" << endl;
 }

使用男朋友类

 //main.c
 #include"BoyFriend.h"
 int main()
 {
     BoyFriend* boy = new BoyFriend("梦凡");
     boy->introduce();
 ​
     BoyFriend* boy2 = new BoyFriend(*boy);  //拷贝构造
     boy2->introduce();
 ​
     delete boy;
     boy = NULL;
     delete boy2;
     boy2 = NULL;
     return 0;
 }
 //打印结果
 我叫梦凡,游戏账号昵称是马化腾,游戏账号等级是201
 拷贝构造
 我叫梦凡,游戏账号昵称是马化腾,游戏账号等级是201
 析构
 析构