（2）类和对象——对象特性

对象的初始化和清理

构造函数和析构函数

对象的初始化和清理是两个非常重要的安全问题

C++利用构造函数和析构函数解决上述问题，两函数被编译器自动调用，完成对象初始化和清理工作。

对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器会提供。

编译器提供的构造函数和析构函数是空实现。

• 构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无需手动调用
• 析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作

构造函数语法：类名（）{ }

• 构造函数，无返回值，不写void；
• 函数名称与类名相同
• 构造函数可以有参数，因此可以发生重载
• 程序在调用对象时会自动调用构造函数，无需手动调用，而且只会调用一次

析构函数语法：~类名（）{ }

• 析构函数，无返回值，不写void；
• 函数名称与类名相同，名称前加符号~
• 析构函数不可以有参数，因此不可以发生重载
• 程序在对象销毁前会自动调用析构函数，无需手动调用，而且只会调用一次

#include<iostream>
using namespace std;
class Person {
public:
	Person() {
		cout << "Person 构造函数调用" << endl;
	}
	~Person() {
		cout << "Person 析构函数调用" << endl;
	}
};
void test01() {
	Person p;//栈上的局部数据，test01执行完毕后，释放这个对象,释放前会调用一次析构函数
}
int main() {
	test01();
	system("pause");
	return 0;
}

构造函数的分类及调用

• 按参数分：有参构造和无参构造
• 按类型分：普通构造和拷贝构造

三种调用方式：括号法、显示法、隐式转换法

#include<iostream>
using namespace std;
class Person {
public:
	Person() {//无参构造（默认构造，因为如果系统提供构造函数的话会提供无参构造）
		cout << "Person 无参构造函数调用" << endl;
	}
	Person(int a) {//有参构造
		age = a;
		cout << "Person 有参构造函数调用" << endl;
	}
	Person(const Person &p) {//拷贝构造函数
		age = p.age;
		cout << "Person 拷贝构造函数调用" << endl;
	}
	~Person() {
		cout << "Person 析构函数调用" << endl;
	}
	int age;
};
void test01() {//调用
//括号法
	Person p1;//默认构造调用,执行完打印一行：Person 无参构造函数调用
	Person p2(10);//有参构造调用，执行完打印一行：Person 有参构造函数调用
	Person p3(p2);//拷贝构造调用，执行完打印一行：Person 拷贝构造函数调用
	cout << "p2年龄：" << p2.age << endl;//执行完打印一行：p2年龄：10
	cout << "p3年龄：" << p3.age << endl;//执行完打印一行：p3年龄：10
//注：调用默认构造函数时不要加()
Person p();//编译器会认为此为一个函数的声明，不会认为是在创建对象，因此不会打印

//显示法
	Person p4;//执行完打印一行：Person 无参构造函数调用
	Person p5 = Person(10);//执行完打印一行：Person 有参构造函数调用
	Person p6 = Person(p5);//执行完打印一行：Person 拷贝构造函数调用

//匿名对象，当前行执行结束后，系统立即回收匿名对象
	Person(10);//执行完打印两行：Person 无参构造函数调用 和 Person 析构函数调用
	cout << "aaaaaaaaa" << endl;//打印 aaaaaaaaa
//注：不要利用拷贝构造函数 初始化匿名对象
//Person(p3);报错：p3重定义，编译器会认为此行是：Person p3; 认为是对象声明
	
//隐式转换法
	Person p7 = 10;//执行完打印一行：Person 有参构造函数调用
	//相当于：Person p7 = Person(10);
	Person p8 = p7;//执行完打印一行：Person 拷贝构造函数调用
	//执行完后释放对象，打印 8 行 Person 析构函数调用
}
int main() {
	test01();
	system("pause");
	return 0;
}

拷贝构造函数调用时机

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

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;
	}
	int m_Age;
};
//使用一个已经创建完毕的对象来初始化一个新对象
void test01() {
	Person p1(20);//执行完此行打印：Person 有参构造函数调用
	Person p2(p1);//执行完此行打印：Person 拷贝构造函数调用
	cout << "p2年龄：" << p2.m_Age << endl;//执行完此行打印：p2年龄：20
}//执行完释放对象，打印两行：Person 析构函数调用

 //值传递的方式给函数参数传值
void doWork(Person p) { }
void test02() {
	Person p;//执行完此行打印：Person 默认构造函数调用
	doWork(p);//执行完此行打印：Person 拷贝构造函数调用
}//执行完释放对象，打印两行：Person 析构函数调用

 //以值方式返回局部对象
Person doWork2() {
	Person p1;//执行完此行打印：Person 默认构造函数调用
	cout << (int*)&p1 << endl;//打印一个地址：00E1F59C
	return p1;//执行完此行打印：Person 拷贝构造函数调用
}//执行完释放对象，打印：Person 析构函数调用
void test03() {
	Person p = doWork2();//转到 doWork2开始运行
	cout << (int*)&p << endl;//打印一个地址：00E1F694
}//执行完释放对象，打印：Person 析构函数调用
int main() {
	//test01();
	//test02();
	test03();
	system("pause");
	return 0;
}

构造函数调用规则

默认情况下，C++编译器至少给一个类添加 3 个函数：

• 默认构造函数（无参，函数体为空）
• 默认析构函数（无参，函数体为空）
• 默认拷贝构造函数，对属性进行值拷贝

调用规则：

• 如果用户定义有参构造函数，C++不再提供默认无参构造，但是会提供默认拷贝构造
• 如果用户定义拷贝构造函数，C++不会再提供其他构造函数

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;
		//}
		int m_Age;
};
void test01() {
	Person p;
	p.m_Age = 18;
	Person p2(p);
	cout << "p2年龄：" << p2.m_Age << endl;
}
int main() {
	test01();//打印：p2年龄：18
	system("pause");
	return 0;
}

深拷贝和浅拷贝

浅拷贝：简单的赋值拷贝操作

深拷贝：在堆区重新申请空间，进行拷贝操作

class Person {
public:
			Person() {
				cout << "Person 默认构造函数调用" << endl;
			}
			Person(int age,int height) {
				cout << "Person 有参构造函数调用" << endl;
				m_Age = age;
				m_Height = new int(height);
			}
			Person(const Person& p) {
				cout << "Person 拷贝构造函数调用" << endl;
				m_Age = p.m_Age;
				//m_Height = p.m_Height;如果是编译器默认实现的话就是此行代码
				m_Height = new int(*p.m_Height);//深拷贝，如果没有此行操作，会引发异常
			}
			~Person() {
				//析构代码，将堆区开辟的数据做释放操作
				if (m_Height != NULL) {
					delete m_Height;
					m_Height = NULL;
				}
				cout << "Person 析构函数调用" << 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();
	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) {
	//初始化列表初始化属性
	}
	int m_A;
	int m_B;
	int m_C;
};
void test01() {
	Person p(10, 20, 30);
	cout << "m_A = " << p.m_A << endl;
	cout << "m_B = " << p.m_B << endl;
	cout << "m_C = " << p.m_C << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

类对象作为类成员

C++类中的成员可以是另一个类的对象，称该成员为对象成员。

class Phone {
public:
	Phone(string pName) {
		m_PName = pName;
		cout << "Phone 构造函数调用" << endl;
	}
	~Phone() {
		cout << "Phone 析构函数调用" << endl;
	}
	string m_PName;//手机品牌名
};
class Person {
public:
	Person(string name, string pName) :m_Name(name), m_Phone(pName) {//Phone m_Phone = pName 隐式转换法
		cout << "Person 构造函数调用" << endl;
	}
	~Person() {
		cout << "Person 析构函数调用" << endl;
	}
	string m_Name;
	Phone m_Phone;
};
//当其他类作为本类的成员，构造时先构造对象，再构造自身；析构则相反
void test01() {
	Person p("张三","苹果手机");
	cout << p.m_Name << " 拿着：" << p.m_Phone.m_PName << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

静态成员

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

静态成员变量

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

静态成员函数

• 所有对象共享同一个函数
• 静态成员函数只能访问静态成员变量

//静态成员变量
class Person {
public:
	static int m_A;//类内声明
private://静态成员变量也是有访问权限的，例如m_B
	static int m_B;
};
int Person::m_A = 100;//类外初始化
int Person::m_B = 300;
//静态成员变量不属于某个对象，所有对象共享一份数据，因此其有两种访问方式
void test01() {
	Person p;//通过对象访问
	cout << p.m_A << endl;//打印 100
	//通过类名访问
	cout << Person::m_A << endl;//打印 100
	Person p2;//验证共享同一份数据
	p2.m_A = 200;
	cout << p.m_A << endl;//打印 200
	//cout << Person::m_B << endl;//“Person::m_B”: 无法访问 private 成员(在“Person”类中声明)
	cout << Person::m_A << endl;//因为已更改，所以打印 200
}
//静态成员函数
class Per {
public:
	static void func() {
		m_C = 100;//静态成员函数 可以 访问 静态成员变量
		//m_B = 200;//静态成员函数 不可以 访问 非静态成员变量  报错
		cout << "static void func 函数调用" << endl;
	}
	static int m_C;//静态成员变量
	int m_D;//非静态成员变量
private://静态成员函数也可以有访问权限，例如：func2
	static void func2() {
		cout << "static void func2 函数调用" << endl;
	}
};
int Per::m_C = 0;
void test02() {
	Per p;//通过对象访问
	p.func();
	Per::func();//通过类名访问
	//Per::func2();//“Per::func2”: 无法访问 private 成员(在“Per”类中声明)	

}
int main() {
	test01();//打印4行，分别为：100，100，200，200
	test02();//打印 2行 static void func 函数调用
	system("pause");
	return 0;
}

C++对象模型和this指针

成员变量和成员函数分开存储

只有非静态成员变量才属于类的对象上

class Person {
	int m_A;//非静态成员变量，属于类的对象上
	static int m_B;//静态成员变量，不属于类的对象上
	void func(){}//非静态成员函数，不属于类的对象上
	static void func2() {}//静态成员函数，不属于类的对象上
};
int Person::m_B = 0;
void test01() {//类Person中什么也不写，调用test01
	Person p;
	//空对象占用内存空间：1
	//C++编译器会给每个空对象也分配一个字节空间，为了区分空对象占内存的位置
	//每个空对象也应该有一个独一无二的内存地址
	cout << "sizeof p = " << sizeof(p) << endl;
}
void test02() {
	Person p;
	cout << "sizeof p = " << sizeof(p) << endl;
}
int main() {
	//test01();//打印：sizeof p = 1
	test02();//打印：sizeof p = 4
	system("pause");
	return 0;
}

this指针概念

每个非静态成员函数只会诞生一份函数实例，即 多个同类型对象会共用一块代码

问题：这一块代码如何区分是哪个对象调用自己

特殊的对象指针——this指针解决上述问题。this指针指向被调用的成员函数所属的对象

this指针是隐含每一个非静态成员函数内的一种指针

this指针无需定义，可直接使用

this指针用途：

• 当形参和成员变量同名时，可以用this指针来区分
• 在类的非静态成员函数中返回对象本身，可使用return *this

class Person {
public:
	Person(int age) {
		this->age = age;//this指针指向的是被调用的成员函数 所属的对象
	}
	Person& PersonAddAge(Person &p) {
		this->age += p.age;
		return *this;//返回p2本体
	}//this指向p2的指针，而*this指向的就是p2对象本体
	int age;
};
void test01() {
	Person p1(18);
	cout << "p1年龄：" << p1.age << endl;//打印：p1年龄：18
}
void test02() {
	Person p1(10);
	Person p2(10);
	p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1);//链式编程思想
	cout << "p2年龄：" << p2.age << endl;
}
int main() {
	test01();
	test02();
	system("pause");
	return 0;
}

空指针访问成员函数

C++中，空指针也可以调用成员函数，但要注意有没有用到this指针

如果用到this指针，需要加以判断保证代码的健壮性

class Person {
public:
	void showClassName() {
		cout << "this is Person class" << endl;
	}
	void showPersonAge() {
		if (this == NULL) {//加上这个判断就不会报错
			return;
		}
		cout << "age = " << this->m_Age << endl;
	}
	int m_Age;
};
void test01() {
	Person* p = NULL;
	p->showClassName();
	p->showPersonAge();//报错 因传入的指针为null
}
int main() {
	test01();
	system("pause");
	return 0;
}

const修饰成员函数

常函数：

• 成员函数前加上const
• 常函数内不可以修改成员属性
• 成员属性声明时加关键字mutable后，在常函数中依然可以修改

常对象：

• 声明对象前加上const
• 常对象只能调用常函数

class Person {
public:
	//this指针本质：指针常量 指针指向不可更改
	//const Person * const this
	void showPerson() const{//成员函数后加const,修饰this指向，让指针指向的值也不可以修改
		//this->m_A = 100; 加上const后会报错
		//this = NULL;//报错，this指针不可以修改指针指向
		this->m_B = 100;
	}
	void func() { m_A = 100; }
	int m_A;
	mutable int m_B;//特殊变量，即使在常函数中，也可以修改这个值，加关键字mutable
};
void test01() {
	Person p;
	p.showPerson();
}
void test02() {
	const Person p;//对象前加const，变为常对象
	p.m_B = 100;//特殊值，常对象下也可以修改
	p.showPerson();//常对象只能调用常函数
	//p.func();报错，常对象不能调用普通成员函数，因为普通成员函数可以修改属性
}
int main() {
	system("pause");
	return 0;
}