拷贝构造

//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.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
拷贝构造

//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
析构
析构