c++基础 面向对象：第五篇（构造，析构，拷贝函数）

一 构造函数

在c++中，类内的成员变量是通过构造函数去初始化的。
构造函数：
在实例化一个对象时，给对象的成员属性初始化。
语法： 类名（）{}

1.与类名同名，没有返回值。

---

2.创建对象时候自动调用构造函数

---

3.假如自己不写构造函数，编译器会给你写，并且时自动调用的。

---

4.构造函数可以有参数，所以也可以函数重载。

---

---

1. 构造函数的分类及其调用

分类：

1. 默认（无参）构造：没有形参的构造函数。假如自己不编写，编译器自动调用的函数。无参不代表没有成员变量参数啊，只是代表没有形参。
2. 有参构造：有形参的构造函数。
3. 拷贝构造函数：
   将一个对象拷贝给另一个对象。
   语法：类名 （const 类名& 变量）{ }

---

调用方式：

​ 括号法

​ 显示法

​ 隐式转换法

class Person {
public:
	//无参（默认）构造函数
	Person() {
		cout << "无参构造函数!" << endl;
	}
	//有参构造函数
	Person(int a) {
		age = a;
		cout << "有参构造函数!" << endl;
	}
	//拷贝构造函数
	Person(const Person& p) {
		age = p.age;
		cout << "拷贝构造函数!" << endl;
	}
	//析构函数
	~Person() {
		cout << "析构函数!" << endl;
	}
public:
	int age;
};
//2、构造函数的调用
//调用无参构造函数
void test01() {
	Person p; //调用无参构造函数
}

//调用有参的构造函数
void test02() {

	//2.1  括号法，常用
	Person p1(10);
	//注意1：调用无参构造函数不能加括号，如果加了编译器认为这是一个函数声明
	//Person p2();

	//2.2 显式法
	Person p2 = Person(10); 
	Person p3 = Person(p2);
	//Person(10)单独写就是匿名对象  当前行结束之后，马上析构

	//2.3 隐式转换法
	Person p4 = 10; // Person p4 = Person(10); 
	Person p5 = p4; // Person p5 = Person(p4); 

	//注意2：不能利用 拷贝构造函数 初始化匿名对象 编译器认为是对象声明
	//Person p5(p4);
}

---

2.构造函数的调用规则

1. 如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造（调用时候本质也是值拷贝，也就是给成员变量直接赋值拷贝），假如你实例化对象是调用默认构造则会出错。提供的默认拷贝构造函数执行的是浅拷贝操作。

2. 如果用户定义拷贝构造函数，c++不会再提供其他构造函数，写了拷贝构造函数，其他的构造函数也要写啊。

class Person {
public:
	//无参（默认）构造函数
	Person() {
		cout << "无参构造函数!" << endl;
	}
	//有参构造函数
	Person(int a) {
		age = a;
		cout << "有参构造函数!" << endl;
	}
	//拷贝构造函数
	Person(const Person& p) {
		age = p.age;
		cout << "拷贝构造函数!" << endl;
	}
	//析构函数
	~Person() {
		cout << "析构函数!" << endl;
	}
public:
	int age;
};

void test01()
{
	Person p1(18);
	//如果不写拷贝构造，编译器会自动添加拷贝构造，并且做浅拷贝操作
	Person p2(p1);
}

void test02()
{
	//如果用户提供有参构造，编译器不会提供默认构造，会提供拷贝构造
	Person p1; //此时如果用户自己没有提供默认构造，会出错
	Person p2(10); //用户提供的有参
	Person p3(p2); //此时如果用户没有提供拷贝构造，编译器会提供

	//如果用户提供拷贝构造，编译器不会提供其他构造函数
	Person p4; //此时如果用户自己没有提供默认构造，会出错
	Person p5(10); //此时如果用户自己没有提供有参，会出错
	Person p6(p5); //用户自己提供拷贝构造
}

int main() {

	test01();

	system("pause");

	return 0;
}

3.拷贝构造函数的调用时机

1. 使用一个已经创建完毕的对象来初始化一个新对象
2. 值传递的方式给函数参数传值
3. 以值方式返回局部对象

class Person
{
public:
	Preson()
	{	
		cout << "无参构造函数!" << endl;
	}
	
	Person(int a)
	{ 
		m_age = a;
		cout << "有参构造函数!" << endl;
	}
	Person(const Person &p)
	{ 
		m_age = p.age;
		cout << "拷贝构造函数!" << endl;
	}
	int m_age;	
};
eg:1. 使用一个已经创建完毕的对象来初始化一个新对象
void test1()
{
	Person p1(10);//有参构造；
	Person p2(p1);//拷贝构造
	Person p3 = p1; //也是拷贝构造
}
eg:2.值传递的方式给函数参数传值
void test2()
{	 
	void fun(Person p) //值传递，本质是创建临时副本，给p赋值
	{
	}
	Person p1;
	fun(p1); //调用fun函数时候，传p1时候就是以值传递的方式给函数参数，会会调用拷贝构造函数哦。
}
eg:3. 以值方式返回局部对象
Person test3()
{
	Person p1(10);
	return p1; //以值方式返回局部变量，本质也是返回一个副本，也会调用拷贝构造函数。
}

---

4.浅拷贝和深拷贝

浅拷贝：就是在拷贝构造函数里面简单的给成员变量赋值操作，并且默认拷贝构造函数也是浅拷贝的操作。
深拷贝：在堆区重新申请空间，进行拷贝赋值给成员变量的操作。
问题：假如你的类中成员变量有指针的话，浅拷贝会带来一个问题就是你在析构函数执行的时候会引发，两次析构同一个堆区的数据问题。
看看下面一段代码：浅拷贝带来的问题

class Person
{
public:
	int m_age;
	int* m_height; //成员变量中有指针，
	Person(int age, int height)
	{
		m_age = age;
		m_height = new int(height);//堆区开辟空间，要释放
		cout << "有参构造函数的调用" << endl;
	}
	//浅拷贝
	//假如自己没写拷贝构造函数，编译器就会自动给你创建这样的拷贝构造函数
	Person(const Person &p)
	{	m_age = p.m_age;
		m_height = p.m_height; //浅拷贝出问题的地方
	}
	~Person() //析构函数使用时机，可以用来释放对象中成员属性的内存；
	{
		if (m_height != NULL)
		{
			delete m_height;//释放m_height指针所指向的内存空间的数据而已啦
			m_height = NULL;
		}
		cout << "析构函数的调用" << endl;
	}
};
void text()
{
	Person p1(18, 160);
	Person p2(p1); 
	cout << p2.m_age << endl;
	cout << *p2.m_height << endl;
}
int main()
{
	text();
	system("pause");
	return 0;
}

测试结果：代码奔溃
解释奔溃原因：

看图，当执行析构函数，析构了p1,释放了堆区空间和栈区空间，这没什么问题，而你析构p2时候，就出问题了，堆区空间还要被释放多一次，这就被重复释放了。

解决办法：有指针成员变量时候，要自己写拷贝构造函数，要自己给成员变量的指针，重新开辟一段新空间，这样就不会重复析构了。

	Person(const Person &p)
	{
		cout << "拷贝构造函数的调用" << endl;
		m_age = p.m_age;
		m_height = new int(*p.m_height);//深拷贝
	}

这就是深拷贝啦。
***
总结：
成员变量有指针时候，要自己写拷贝构造函数，给成员变量的指针重新赋值新的堆区空间哦。这就可以避免浅拷贝赋值问题了。

二 析构函数

在c++中，清理对象里的成员变量是通过析构函数去执行的。
析构函数：
在对象销毁前，调用析构函数执行清理工作
语法：~类名（）{}

1.函数名与类名同名，在函数名加~

---

2.创建对象时候自动调用构造函数

---

3.假如自己不写构造函数，编译器会给你写，并且时自动调用的。

---

class Person
{
public:
	Person() //构造函数
	{
		cout << "Person 的构造函数调用" << endl;
	}
	~Person() // 析构函数
	{
		cout << "Person 的析构函数调用" << endl;
	}
};
void test()
{
	Person p1;// 创建一个对象时候,自动调用了析构函数；该执行完后，调用析构函数，释放该对象
}
int main()
{
	
	system("pause");
	return 0;
}

---

三 列表初始化

c++中提供一种列表的方式给成员变量赋初值。
语法：
构造函数()：属性1(值1),属性2（值2）… { }

class Person {
public:

	传统方式初始化
	Person(int a, int b, int c) 
	{
		m_A = a;
		m_B = b;
		m_C = c;
	}

	初始化列表方式初始化
	Person(int a, int b, int c) :m_A(a), m_B(b), m_C(c) { }
private:
	int m_A;
	int m_B;
	int m_C;
};

传统初始化的方式和列表初始化的方式达到的效果是一样的，但列表初始化的效率更高，我们更推荐列表初始化的方式。

---

四 类对象作为类的成员

在c++中，可以用一个类的对象作为另一个类的成员；
语法：

class 类名1
{ 
}；
class 类名2  
{
	类名1 对象；//用一个类1的对象作为类2的成员；
}；

问题引入：
那请问类2去创建对象时候调用构造函数时候是先调用类1还是类2呢？析构调用顺序呢？
看下面的例子：
定义一个手机类，定义一个人类，人类中有手机类的对象，用人类去创建对象，测试构造和析构的调用顺序。

class Phone
{
public:
	Phone()
	{
		cout << "Phone的构造函数调用" << endl;

	}
	~Phone()
	{
		cout << "Phone的析构函数的调用" << endl;
	}
};
class Person
{
public:
	Phone m_phone; //用Phone的对象作为Person的成员变量；
	Person()
	{
		cout << "Person的构造函数调用" << endl;
	}
	~Person()
	{
		cout << "Person的析构函数调用" << endl;
	}

};
void text()
{
	Person p; //创建Person的一个对象p
}
int main()
{
	text();
	system("pause");
	return 0;
}

测试结果：

总结：
构造函数的调用顺序为，从里到外，析构则相反。

---

五 静态成员

静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员。

1. 静态成员变量

1. 所有对象共享同一份数据
2. 在编译阶段分配内存
3. 类内声明，类外初始化

2. 静态成员函数

1.程序共享一个函数

2.静态成员函数只能访问静态成员变量

class Person
{

public:
	static int m_A; //静态成员变量
	int m_B; //  非静态成员变量

	//静态成员函数特点：
	//1 程序共享一个函数。
	//2 静态成员函数只能访问静态成员变量
	
	static void func()
	{
		
		m_A = 100;
		m_B = 100; //错误，不可以访问非静态成员变量
	}


private:

	//静态成员函数也是有访问权限的
	static void func2()
	{
		
	}
};
int Person::m_A = 10;


void test01()
{
	//静态成员变量两种访问方式

	//1、通过对象
	Person p1;
	p1.func();

	//2、通过类名
	Person::func();
	
	Person::func2(); //私有权限访问不到
}

int main() {

	test01();

	system("pause");

	return 0;
}

3. 非静态成员变量

1.只有非静态成员变量属于类的对象上的，其他类的静态成员，类的普通函数都不属于类的对象上的，这就说明类的大小与这无关。
成员变量与成员函数是分开存储的，可以通过创建一个对象来访问该对象的字节数来认证。

---

六 this指针

this指针不要想的太复杂，就是在创建对象时候，this指针就指向该对象。
并且在每一个成员函数内部都有一个隐藏的this指针形参，静态成员函数没有this指针

为什么要有this指针呢？
举个例子，就比如我在宿舍6个人但只有我一个有篮球，可是却又宿舍人都分别不同时候去用它，我是如何通过区分哪个人去用我的篮球？当然通过名字区分啊。这就类比于this指针就是对象的一个身份，当你要创建多个对象时候，我们是如何区分不同的对象要使用同一个函数里面的数据的，就是通过this指针指向了不同的对象，用这个不同的对象来区分的。
这能有什么用呢？
就是可以通过this指针去操作成员函数里面的成员变量。有人说，我不要this指针也可以啊，那是当然可以，可是你可以的前提是编译器偷偷给你做了this指针的指向了，那为什么还要自己显示写出来呢？因为这样可以更好区分类的成员变量和你传入的形参咯。

class Person
{
public:

	Person(int age)
	{
		//1、当形参和成员变量同名时，可用this指针来区分
		this->age = age;
	}

	Person& PersonAddPerson(Person p)
	{
		this->age += p.age;
		//返回对象本身
		return *this;
	}

	int age;
};

void test01()
{
	Person p1(10);
	cout << "p1.age = " << p1.age << endl;

	Person p2(10);
	p2.PersonAddPerson(p1).PersonAddPerson(p1).PersonAddPerson(p1);
	cout << "p2.age = " << p2.age << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

---

七 const修饰成员

常函数：

1. 成员函数后加const后我们称为这个函数为常函数
2. 常函数内不可以修改成员属性
3. 成员属性声明时加关键字mutable后，在常函数中依然可以修改

常对象：

1. 声明对象前加const称该对象为常对象
2. 常对象只能调用常函数

# include<iostream>
# include<string>
using namespace std;
常函数
1.常函数里面不可以修改成员属性
2.假如成员属性加了mutable 也是可以修改的
3.常对象只能调用常函数
class Person
{
public:
	int m_age;
	mutable int m_age1;
	 // this指针本质 Person* const this;
	void func() const//在成员函数后面加了const的本质也是修饰this指针，
					//而this指针的本质是指针常量，也就是指针的值是不可以修改的
	{
		m_age = 100;//错误，默认是this->m_age;因为在常函数中，
					//该m_age是不可以修改的值，也就是说this指向的值是不可以修改的了
		m_age1 = 100; //，没问题，加了mutable关键字，可以在常函数中修改
	}
	void func1()
	{
		m_age = 100;
	}

};
int main()
{
	const Person p1; //常对象
	p1.func();//没问题，常对象可以调用常函数
	p1.func1();//错误，因为常对象说明里面的成员属性属性不可以修改了，
	          //你在调用该函数可以间接的去修改成员属性啦。。。所以有矛盾
	system("pause");
	return 0;
}

---

总结：
分享了构造，构造分类机及其调用，拷贝，拷贝调用时机 深浅拷贝，析构，this指针，常函数，静态成员。也不多，下篇继续分享新的内容。