亲宝软件园·资讯

展开

C++构造和析构

qq_24409999 人气:0

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;
}

总结

本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注的更多内容!    

加载全部内容

相关教程
猜你喜欢
用户评论