构造、析构、拷贝

骑猪看日落 2022-03-19 11:37 222阅读 0赞

### 文章目录 ###

*   *  构造函数
     *   *  构造注意小细节
     *  析构函数
     *  应用场景
     *  浅拷贝、深拷贝

## 构造函数 ##

*  类提供默认的无参构造函数和拷贝构造函数，如果自己手动添加构造函数，默认将不复存在，如果提供显示的构造，默认无参构造将会被隐藏，但是默认拷贝还在；如果显示的写了一个拷贝构造函数 ，会隐藏默认的无参构造函数和默认的拷贝构造函数

### 构造注意小细节 ###

class Person
    {
    public:
    	Person()
    	{
    		cout << "无参构造" << endl;
    	}
    	Person(int a)
    	{
    		cout << "有参构造" << endl;
    	}
    };
    
    //  调用情况1.
    Person p;   //调用了无参构造
    Person p();  //没有调用了无参构造， 
    
    
    // 调用情况2.
    Person* p1 = new Person; // //调用了无参构造
    Person* p2 = new Person();  //调用了无参构造

tips : 省事的话调用无参构造，直接不加括号

--------------------

## 析构函数 ##

*  类提供默认的析构函数，如果手动添加默认将不存在
 *  析构顺序和构造顺序相反

## 应用场景 ##

Test.h

class Test
    { 
    public:
    	Test(int x, int y)
    	{ 
    		m_x = x;
    		m_y = y;
    		cout << "调用了有参数的构造函数" << endl;
    	}
    
    	//无参数的构造函数
    	Test(){ 
    		m_x = 0;
    		m_y = 0;
    		cout << "调用了无参数的构造函数" << endl;
    	}
    
    
    	//拷贝构造函数 ，想通过另一个Test对象 another 将本对象进行拷贝
    	Test(const Test & another)
    	{ 
    		m_x = another.m_x;
    		m_y = another.m_y;
    		cout << "调用了拷贝构造函数" << endl;
    	}
    
    	//等号操作符
    	void operator = (const Test &t)
    	{ 
    		cout << "调用了=号操作符" << endl;
    		m_x = t.m_x;
    		m_y = t.m_y;
    	}
    
    	void printT()
    	{ 
    		cout << "x : " << m_x << ", y : " << m_y << endl;
    	}
    
    	//提供一个析构函数
    	~Test()
    	{ 
    		cout << "~Test（）析构函数被执行了" << endl;
    		cout << "(" << m_x << ", " << m_y << ")" << "被析构了" << endl;
    	}
    
    private:
    	int m_x;
    	int m_y;
    };

1. 
    void test1()
    { 
    	Test t1(1, 2); //调用t1的有参构造
    	Test t2(t1); //调用 t2的拷贝构造
    	//通过t1 给t2 进行赋值
    	t2.printT();
    }
    
    
    
    2.
    void test2()
    { 
    	Test t1(1, 2);
    	Test t2;
    	t2 = t1; //调用的不是拷贝构造函数，调用的是=号操作符，也能够完成将t1的值给t2 但不是调用t2的拷贝构造函数。
    }
    
    
    3.
    void func(Test t) //Test t(t1); //会调用局部变量t的拷贝构造函数
    { 
    	cout << "func begin..." << endl;
    	t.printT();
    	cout << "func end..." << endl;
    
    }
    void test3()
    { 
    	cout << "test3 begin ..." << endl;
    	Test t1(10, 20); //创建了一个t1的对象。通过t1的有参数的构造函数
    	func(t1);
    
    	cout << "test3 end..." << endl;
    }
    
    
    
    
    
    4. 
    Test func2()
    { 
    	cout << "func2 begin..." << endl;
    	Test temp(10, 20); //调用temp的带参数构造函数 
    	cout << "func2 end.." << endl;
    	return temp; // 有一个临时的匿名对象 = temp ，把temp的数据给到了临时的匿名对象, 会调用这个临时匿名对象的拷贝构造函数， 将temp传进去。
    				
    }
    void test4() 
    { 
    	cout << "test4 begin " << endl;
    	func2();
    
    	//匿名对象在此被析构了， 如果一个临时的匿名对象，没有任何变量去接收它，编译器认为这个临时匿名对象没有用处。
    	//编译器会立刻销毁这个临时的匿名对象
    	cout << "test4 end" << endl;
    }
    
    
    
    5.
    void test5()
    { 
    	cout << "test5 begin ..." << endl;
    	Test t1 = func2();//如果有一个变量去接收这个临时的匿名对象， 编译器认为这个匿名对象转正了，就不会立刻给他销毁。
    							//t1 = 匿名的临时对象 为什么不会发生拷贝构造
    							// 此时的t1 去接收这个匿名的临时对象不是 重新创建一个t1 而是给这个匿名对象起个名字就叫t1
    							//一旦这个匿名对象有了自己的名字，编译器就不会立刻给这个匿名对象销毁了，
    							//就当普通局部变量处理了
    
    	cout << "test5 end..." << endl;
    
    	//在此时析构的t1
    }
    
    
    
    
    6.
    void test6()
    { 
    	cout << "test6 begin..." << endl;
    	Test t1; //调用t1的无参数构造函数
    	t1 = func2(); //调用的=号操作符 ,,t1 = 匿名对象。 调用了t1的=号操作符。
    						//此时匿名没有被转正，匿名没有自己的名字， 匿名对象这个内存没有自己的别名， 编译器就会立刻销毁。
    	cout << "test6 end..." << endl;
    }

--------------------

## 浅拷贝、深拷贝 ##

*  有时候成员变量具有指针特性，一旦进行拷贝，指针指向同一块内存，当释放的时候，如果同一块内存被两次释放，程序将崩溃。这称之为浅拷贝。深拷贝的意思是将**拷贝构造**或者 **=操作符重载**的函数重写，重新开辟一块内存给需要赋值的指针，这样浅拷贝的问题将解决。

例子：

person.h

#pragma once
    #include <iostream>
    using namespace std;
    
    
    class Person
    { 
    public:
    	//有参数的构造函数
    	Person(int id, const char *name)
    	{ 
    		m_id = id;
    		int len = strlen(name);
    		m_name = (char*)malloc(len + 1);
    		strcpy_s(m_name, len + 1, name);
    	}
    
    	Person(const Person& another)
    	{ 
    		m_id = another.m_id;
    		int len = strlen(another.m_name);
    		m_name = (char*)malloc(len + 1);
    		strcpy_s(m_name, len+1, another.m_name);
    	}
    
    	~Person()
    	{ 
    		if (m_name != NULL)
    		{ 
    			free(m_name);
    			m_name = NULL;
    		}
    	}
    
    private:
    	int m_id;
    	char *m_name;
    };

user.c

#include "person.h"
    using namespace std;
    
    
    int main()
    { 
    	Person t1(1, "zhang3");
    
    	//如果不提供一个显示的拷贝构造函数， 通过系统自带的默认拷贝构造函数,程序会崩溃
    	Person t2(t1); //会调用t2的拷贝构造函数，将t1的值拷贝给t2
        return 0;
    }