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

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

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

//拷贝构造函数
class Complex
{
private:
	int real;
	int image;
public:
	Complex():real(0), image(0)  //缺省的构造函数
	{
		cout << "Create Complex:()"  << endl;
	}           
	Complex(int r, int i) :real(r), image(i)   //带参数的构造函数
	{
		cout << "Create Complex(int,int) " << endl;
	}
	~Complex()
	{
		cout << "Destroy Complex: "  << endl;
	}
	//不加引用&,则会变为无穷递归的形式,设置成值类型,必须要构建对象,而设计成引用,只是当前对象的别名
	Complex(const Complex& com) :real(com.real), image(com.image)           //拷贝构造函数  形参必须是引用
	{                                         //为了防止拷贝构造过程中改变cb对象 加const
		//real = com.real;
		//Complex cc(cb);  -> Complex(&cc,cb); 
		cout << "Copy Create Complex(const Complex&)" << this << endl;
	}
};

void fun(Complex cs)
{
}

int main()
{
	Complex ca;
	Complex cb(1,2);//用c1初始化c2
	Complex cc(cb);     //用一个对象初始化另一个对象时 调动拷贝构造
	fun(ca);

	return 0;
}

 调试结果:

C++:拷贝构造函数,深拷贝,浅拷贝_第1张图片

运行结果:

 C++:拷贝构造函数,深拷贝,浅拷贝_第2张图片

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

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

  1. 用旧对象去初始化新对象
  2. 值传递—参数是类类型的值类型,从实参传递给形参的过程,是用实参去构造形参
  3. 函数返回值是值类型–用局部对象去构造临时对象调用拷贝构造
class Person
{
public:
    //无参(默认)构造函数
    Person() {
        cout << "Person的默认构造函数调用!" << endl;
    }
    Person(int age) {
        cout << "Person有参构造函数调用!" << endl;
        m_Age = age;
    }
    Person(const Person& p) {
        cout << "Person拷贝构造函数调用!" << endl;
        m_Age = p.m_Age;
    }
    ~Person() {
        cout << "Person的析构函数调用!" << endl;
    }
public:
    int m_Age;
};

//1 使用一个已经创建完毕的对象来初始化一个新对象
void test01()
{
    Person p1(20);  //创建一个新对象p1
    Person p2(p1);  //拷贝 把p1的全部拷贝过来

    cout << "P2的年龄为: " <

C++:拷贝构造函数,深拷贝,浅拷贝_第3张图片 

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

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

练习1:写拷贝构造函数

//写拷贝构造函数
class CGoods
{
private:
	enum { LEN=20 };   //枚举型是常量    
	char Name[LEN];     //20
	int Amount;
	float Price;
	float Total_value;         //32
public:
	CGoods() :Name{}, Amount{}, Price{}, Total_value{} //无参构造函数
	{

	}
	CGoods(const char* name, int amount, float price)
	{
		strcpy_s(Name, LEN, name);
		Amount = amount;
		Price = price;
		Total_value = Amount * Price;
	}


};


int main()
{
	CGoods book("C++", 10, 128.0f);
	CGoods bx(book);   //没有写 系统提供一个缺省的拷贝构造函数 按位拷贝
	return 0;
}

运行结果: 

C++:拷贝构造函数,深拷贝,浅拷贝_第4张图片

写入拷贝构造函数:

//写拷贝构造函数
class CGoods
{
private:
	enum { LEN=20 };   //枚举型是常量    
	char Name[LEN];     //20
	int Amount;
	float Price;
	float Total_value;         //32
public:
	CGoods() :Name{}, Amount{}, Price{}, Total_value{} //无参构造函数
	{

	}
	CGoods(const char* name, int amount, float price)
	{
		strcpy_s(Name, LEN, name);
		Amount = amount;
		Price = price;
		Total_value = Amount * Price;
	}

	CGoods(const CGoods& c)   //浅拷贝
	{
		strcpy_s(Name, LEN, c.Name);
		Amount = c.Amount;
		Price = c.Price;
		Total_value = c.Total_value;
		cout << "Copy CGoods(const CGoods&): " << this << endl;
	}
};

int main()
{
	CGoods book("C++", 10, 128.0f);
	CGoods bx(book);   //没有写 系统提供一个缺省的拷贝构造函数 按位拷贝
	return 0;
}

 C++:拷贝构造函数,深拷贝,浅拷贝_第5张图片

练习2:写拷贝构造函数 

C++:拷贝构造函数,深拷贝,浅拷贝_第6张图片

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

C++:拷贝构造函数,深拷贝,浅拷贝_第7张图片

四、深拷贝和浅拷贝:

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

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

class Person {
public:
    Person() 
    {
        cout << "无参构造函数!" << endl;
    }
    //有参构造函数
    Person(int age)
    {
        m_Age = age;
        cout << "有参构造函数!" << endl;
  
    }
    //析构函数
    ~Person()
    {
        cout << "析构函数!" << endl;
    }
    int m_Age;    //年龄
};

void test01()
{
    Person p1(18);
    cout << "p1的年龄: " << p1.m_Age<

运行结果:

C++:拷贝构造函数,深拷贝,浅拷贝_第8张图片

浅拷贝:简单的赋值拷贝操作
深拷贝:在堆区重新申请空间,进行拷贝操作
#include 
using namespace std;


class Person {
public:
    Person() 
    {
        cout << "无参构造函数!" << endl;
    }
    //有参构造函数
    Person(int age, int height)
    {
        m_Age = age; 
        m_Height = new int(height);
        cout << "有参构造函数!" << endl;
    }

    //自己实现拷贝构造函数,解决浅拷贝带来的问题
    Person(const Person& p)
    {
        cout<< "拷贝构造函数!" << endl;

        //如果不利用深拷贝在堆区创建新内存,会导致浅拷贝带来的重复释放堆区问题
        m_Age = p.m_Age;
       // m_height = new int(*p.m_height);  编译器默认实现就是这行代码
        
        //深拷贝操作
        m_Height=new int(*p.m_Height);
    }

    //析构函数
    ~Person()
    {
        //析构代码,将堆区开辟的数据做释放操作
        if (m_Height != NULL)
        {
            delete m_Height;
            m_Height = NULL;
        }
        cout << "析构函数!" << endl;

    }
    int m_Age;       //年龄
    int* m_Height;   //身高    开辟到堆区
};

void test01()
{
    Person p1(18,160);
    cout << "p1的年龄: " << p1.m_Age<< " 身高: " << *p1.m_Height << endl;

    Person p2(p1);//调用拷贝构造函数   编译器做了一个浅拷贝的工作
    cout << "p2的年龄: " << p2.m_Age << " 身高: " << *p2.m_Height << endl;
}


int main()
{
    test01();
}

运行结果:

C++:拷贝构造函数,深拷贝,浅拷贝_第9张图片

如果属性有在堆区开辟的,一定要自己提供拷贝构造函数,防止浅拷贝带来的问题

你可能感兴趣的:(C++,c++)