C++的構造和析構實例分析

本篇內容主要講解“C++的構造和析構實例分析”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實用性強。下面就讓小編來帶大家學習“C++的構造和析構實例分析”吧!

1. 構造函數 

1.1 構造函數長什么樣子

(1) 函數名和類名相同

(2) 沒有返回值

(3) 如果不寫構造函數，任何類中都存在一個默認的構造函數

I 默認的構造函數是無參的

II 當我們自己寫了構造函數，默認的構造函數就不存在

(4) 構造函數在構造對象的時候調用

(5) delete可以用來刪掉默認的函數

(6) 指定使用默認的無參構造函數，用default說明

(7) 允許構造函數調用另一個構造函數，只是要用初始化參數列表的寫法

(8) 初始化參數列表 ： 只有構造函數有

I 構造函數名(參數1，參數2,…):成員1(參數1)，成員2(參數2),…{}

II 避免形參名和數據成員名相同的導致問題

1.2 構造函數干嘛的

(1) 構造函數用來構造對象

(2) 構造函數更多是用來初始化數據成員

1.3 思考

(1)為什么不寫構造函數可以構造對象? 是因為存在一個默認的無參構造函數，所以可以構造無參對象

(2) 構造函數重載為了什么? 為了構造不同長相的對象。

#include <iostream>
using namespace std;
class MM 
{
public:
	//MM() = delete;     刪掉默認的構造函數
	MM(string mmName, int mmAge) 
	{
		name = mmName;
		age = mmAge;
		cout << "帶參構造函數" << endl;
	}
	//MM() 
	//{
	//	cout << "無參構造函數" << endl;
	//}
	MM() = default;  //使用的是默認無參構造函數
	void print() 
	{
		cout << name << " " << age << endl;
	}
protected:
	string name="Lisa";
	int age=18;
};
//為了能夠構造不同長相的對象，我們會給構造函數缺省處理
class Boy
{
public:
	//Boy(string mname="", int mage=19) 
	//{
	//	name = mname;
	//	age = mage;
	//}
	//上面函數 等效可以實現下面三個函數的功能
	Boy() {}
	Boy(string mName) { name = mName; }
	//出錯：沒有與之匹配的構造函數
	Boy(string mName, int mage) { name = mName; age = mage; }
protected:
	string name;
	int age;
};
//初始化參數列表的寫法
string girlName = "Baby";
class  Student 
{
public:
	Student(string mname="", int mage=18) :name(mname), age(mage) 
	{
		cout << "初始化參數列表" << endl;
		//繼承和類的組合必須采用初始化參數列表寫法
	}
	Student(int mage) :name(girlName), age(mage) {}
protected:
	string name;
	int age;
};
//構造函數可以調用另一個構造函數初始化數據
class TT 
{
public:
	TT(string name, int age) :name(name), age(age) {}
	//委托構造：允許構造函數調用另一個構造函數
	TT():TT("默認",18) {}     //沒有給數據初始化
	void print() 
	{
		cout << name << "\t" << age << endl;
	}
protected:
	string name;
	int age;
};
int main() 
{
	//MM mm;     構造無參的對象，需要無參構造函數
	MM mm("mm", 28);
	mm.print();
	MM girl;
	girl.print();
	Boy boy1;
	Boy boy2("流浪之子");
	Boy boy3("王子", 18);
	TT  tt;
	tt.print();
	return 0;
}

2. 析構函數

2.1 析構函數長什么樣子?

(1) 無返回值

(2) 無參數

(3) 函數名: ~類名

(4) 不寫的話會存在默認的析構函數

(5) 析構函數不需要自己 調用，對象死亡的之前會調用析構函數

2.2 析構函數用來干嘛?（什么時候需要自己手動寫析構函數）

(1) 當類中的數據成員是指針，并且動態申請內存就需要手寫析構

(2) 析構函數用來釋放數據成員申請動態內存

3. 拷貝構造函數

-> 拷貝構造函數也是構造函數，長相和構造函數一樣的，只是參數是固定 .拷貝構造函數唯一的參數是對對象引用

-> 不寫拷貝構造函數，也存在一個默認的拷貝構造函數

-> 拷貝構造函數作用: 通過一個對象去初始化另一個對象

問題 

I 什么時候調用拷貝構造?

答：當通過一個對象去創建出來另一個新的對象時候需要調用拷貝

II 拷貝構造什么時候需要加const修飾參數？

答：當存在匿名對象賦值操作的時候，必須要const修飾

#include <iostream>
#include <string>
using namespace std;
class MM 
{
public:
	MM() = default;
	MM(string name, int age) :name(name), age(age) {}
	void print() 
	{
		cout << name << "\t" << age << endl;
	}
	//拷貝構造
	MM(const MM& mm)			 //MM girl(mm);
	{
		name = mm.name;  //girl.name=mm.name
		age = mm.age;	 //girl.age=mm.age
		cout << "拷貝構造" << endl;
	}

protected:
	string name;
	int age;
};
void printData(MM mm)   //MM mm=實參;
{ 
	mm.print();
}
void printData2(MM& mm) //不存在拷貝本
{
	mm.print();
}
int main() 
{
	MM mm("mm", 18);
	mm.print();
	//顯示調用調用
	cout << "顯示調用調用" << endl;
	MM girl(mm);        //通過一個對象創建另一個對象
	girl.print();
	//隱式調用
	cout << "隱式調用" << endl;
	MM girl2 = mm;		//拷貝構造
	girl2.print();
	MM girl3;
	girl3 = mm;			//運算符重載
	girl3.print();		
	//函數傳參
	cout << "第一種調用形態" << endl;
	printData(mm);
	cout << "第二種調用形態" << endl;
	printData2(mm);
	//無名對象 匿名對象
	MM temp;
	temp = MM("匿名", 18);
	temp.print();
	//匿名對象創建對象時候，拷貝構造一定要用const修飾
	MM temp2 = MM("匿名", 199);
	return 0;
}

4. 深淺拷貝 

（1）淺拷貝: 默認的拷貝構造叫做淺拷貝

（2）深拷貝: 拷貝構造函數中做了new內存操作，并且做拷貝賦值的操作

#include<iostream>
#include <cstring>
#include <string>
using namespace std;
class MM 
{
public:
	MM(const char* mname, int age) :age(age)
	{
		name = new char[strlen(mname) + 1];
		strcpy_s(name, strlen(mname) + 1, mname);
	}
	void print() 
	{
		cout << name << "\t" << age << endl;
	}
	MM(const MM& object) 
	{
		//name = object.name;
		name = new char[strlen(object.name) + 1];
		strcpy_s(name, strlen(object.name) + 1, object.name);
		//name = object.name;
		age = object.age;
	}
	~MM() 
	{
		delete[] name;
	}
protected:
	char* name;
	int age;
};
int main() 
{
	{
		MM mm("baby", 19);
		MM girl(mm);
		MM gm = mm;
		mm.print();
		girl.print();
		gm.print();
	}
	return 0;
}

5. 構造和析構順序問題

（1）普通對象，構造順序和析構順序是相反

（2）new出來的對象，delete會直接調用析構函數

（3）static對象，當程序關閉的時候，生命周期才結束，所以是最后釋放

#include <iostream>
#include <string>
using namespace std;
class MM 
{
public:
	MM(string name="x") :name(name) {
		cout << name;
	}
	~MM(){
		cout << name;
	}
protected:
	string name;
};
int main() 
{
	{
		MM mm1("A");			//A
		static MM mm2("B");		//B   程序關閉時候才死亡，最后析構
		MM* p3 = new MM("C");	//C
		MM mm4[4];				//xxxx
		delete p3;				//C  delete 直接調用析構
		p3 = nullptr;
								//xxxxAB
	}
	//ABCxxxxCxxxxAB
	return 0;
}

6. C++結構體

#include <iostream>
#include <string>
using namespace std;
struct MM 
{
	//默認為公有屬性
	//類中默認屬性是私有屬性
//protected:
	string name;
	int age;
public:
	MM(string name) :name(name) 
	{
		cout << "構造函數" << endl;
	}
	MM(const MM& object) 
	{
		name = object.name;
		age = object.age;	
		cout << "拷貝構造" << endl;
	}
	~MM() 
	{
	}
};
int main() 
{
	//采用創建時候賦值的方式，也是調用構造函數
	//MM object = { "lisa",19 };  錯誤，因為沒有兩個參數的構造函數
	MM  object = { "lisa" };
	cout << object.name << "\t" << object.age << endl;
	//C++結構體一旦寫了構造函數，就必須按照C++類的方式的去用
	MM mm(object);
	cout << mm.name << "\t" << mm.age << endl;
	return 0;
}

答疑：

• 為什么要手動寫析構函數? 因為默認的不會釋放數據成員動態申請的內存

• 函數名和類型相同函數叫做構造函數

• 函數名字是~類名的無參函數叫做析構函數

• 以對象的引用為參數的構造函數叫做拷貝構造函數(復制構造函數)

• 怎么寫出來，默認的構造函數，就是那種在沒有傳參的時候的那一串垃圾值

class Boy
{
public:
	Boy() {}
	void print() 
	{
		cout << a << "\t" << b << "\t" << c << endl;
	}
protected:
	int a;
	int b;
	int c;
};
int main()
{
    return 0;
}

到此，相信大家對“C++的構造和析構實例分析”有了更深的了解，不妨來實際操作一番吧！這里是億速云網站，更多相關內容可以進入相關頻道進行查詢，關注我們，繼續學習！