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

防止类型隐式转换

深拷贝和浅拷贝

浅拷贝----复制地址

对内存地址的复制，让目标指针和源指针指向同块内存

通过其中一个指针去释放内存，其他指向改内存的指针会成为野指针

20200315151723.png

深拷贝----复制内存

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

l两个对象互不影响，互不干涉

深拷贝.png

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

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

深浅拷贝示例程序

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

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