C++之构造进阶之拷贝构造

拷贝构造函数的概述

拷贝构造函数的本质是构造函数。

调用拷贝构造的时机：旧对象给新对象初始化。

用户不提供拷贝构造，编译器将会提供一个浅拷贝的拷贝构造函数。

如果类中有指针成员 用户必须实现深拷贝的拷贝构造函数。

//对象只有定义的时候是新对象 其他任何时候都是旧对象
Data ob1(10);
//拷贝构造：旧对象 给 新对象 初始化
Data ob2 = ob1;//调用拷贝构造

cout<<ob1.m_A<<" "<<ob2.m_A<<endl;

以下会调用拷贝构造

Data ob1(10);
Data ob2;
ob2=ob1;
cout<<ob1.m_A<<" "<<ob2.m_A<<endl;

拷贝构造函数的定义形式

Data(const Data &obj){
    m_a = obj.m_a;
    cout<<"拷贝构造函数"<<endl;
}

拷贝构造调用时机

1.旧对象 给 新对象 初始化 将调用拷贝构造函数。

Data obj1;
Data obj2=obj1; //调用拷贝构造

2.普通对象作为函数的形参会调用拷贝构造函数

void func(Data obj){ //调用拷贝构造
    
}
void test(){
    Data obj1;
    func(obj1);
}

3.函数的返回值为普通对象在VS中将调用拷贝构造，Linux和Qt不会

Data func(void){
    Data ob1;
    return ob1;
}
int main(){
    Data obj1 = func();
    return 0;
}

4.就对象初始化新对象

 Data obj1(10);
 Data obj2(obj1);

无参构造 有参构造 拷贝构造的屏蔽关系

1.只要用户提供构造函数(不管有无参数)，拷贝构造函数 都会屏蔽系统默认的无参构造

class Data
{
public:
    int m_A;
public:
    Data(int a)
    {
        m_A = a;
        cout<<"有参构造m_A="<<m_A<<endl;
    }
};

void test()
{
    //此处实例化对象ob1调用无参构造，但是默认的无参构造被有参构造屏蔽，所以调用默认无参构造函数失败，不能实例化对象
    Data2 ob1;//err
    Data2 ob2(20);//ok
}

PS：任何类用户最好实现无参构造、有参构造

2.用户提供无参构造 有参构造 都不能屏蔽 默认的拷贝构造。

PS:用户提供的构造函数（无参、有参、拷贝构造函数）只能屏蔽 默认无参构造函数。

用户实现 无参构造、有参构造、拷贝构造、析构函数 的时机

1. 如果类中没有指针成员（用户只需要实现，无参、有参构造函数）

2. 如果类中有指针成员（

   用户除了实现无参、有参构造函数

   必须实现析构函数：完成指针成员 指向的堆区空间 释放动作

   必须实现拷贝构造函数：完成对象间的深拷贝问题。

   必须实现重载赋值运算符=：完成对象间的深拷贝问题。

   ）

#include <iostream>
#include <string.h>
using namespace std;
class Person
{
private:
    char *m_Name;
    int m_Num;
public:
    Person();
    Person(char *name, int num);
    ~Person();
    Person(const Person &obj);
    void showPerson();
};

int main(int argc, char *argv[])
{
    Person a("阿斯巴甜", 18);
    a.showPerson();

    Person b=a;
    b.showPerson();
    return 0;
}

Person::Person()
{
    m_Name=NULL;
    m_Num=0;
    cout<<"无参构造"<<endl;
}

Person::Person(char *name, int num)
{
    //根据name指向的字符串长度 从堆区申请足够的空间 存储
    m_Name = (char *)calloc(1, strlen(name)+1);
    //将文字常量区的字符串 拷贝到堆区
    strcpy(m_Name, name);

    m_Num = num;
    cout<<"有参构造函数"<<m_Name<<" "<<m_Num<<endl;
}

Person::~Person()
{
    cout<<"析构函数"<<m_Name<<" "<<m_Num<<endl;
    if(m_Name != NULL)
    {
        free(m_Name);
        m_Name = NULL;
    }
}

Person::Person(const Person &obj)
{
    //根据ob.mName指向的字符串长度 从堆区申请足够的空间 存储
    m_Name = (char *)calloc(1, strlen(obj.m_Name)+1);
    strcpy(m_Name, obj.m_Name);
    m_Num = obj.m_Num;
    cout<<"拷贝构造"<<endl;

}
void Person::showPerson()
{
    cout<<m_Name<<" "<<m_Num<<endl;
}