c++——核心编程

核心编程，针对C++面向对象编程技术

1.内存分区模型

内存分区模型

C++程序在执行时，将内存划分为4个区域：

• 代码区：存放函数体的二进制代码，由操作系统进行管理的。
• 全局区：存放全局变量、静态变量以及常量。
• 栈区：由编译器自动分配释放，存放函数的参数值，局部变量等。
• 堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收。

内存四区意义： 不同区域存放的数据，赋予不同的生命周期，使编程更加灵活。

1.程序运行前

在程序编译后，生成exe可执行程序，未执行该程序前分为两个区域。
代码区：

• 存放CPU执行的机器指令。
• 代码区是共享的，共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可。
• 代码区是只读的，原因是防止程序意外的修改了它的指令。

全局区：

• 全局变量和静态变量存放。
  • 使用static修饰的变量为静态变量。
• 全局变量还包括了常量区，字符串常量和其他常量也存放在此。
• 该区域的数据在程序结束后由操作系统释放。

在全局区中的数据：全局变量、静态变量、字符串常量和全局常量
不在全局区中的数据：局部变量、局部常量

2.程序运行后

栈区：

• 由编译器自动分配释放，存放函数的参数值，局部变量等。
• 注意事项：不要返回局部变量的地址，栈区开辟的数据由编译器自动释放（要是一个函数中的局部变量，在执行完这个函数后会自动释放）。
• 形参数据也会存放在栈区

堆区：

• 由程序员分配释放，若程序员不释放，程序结束时由操作系统回收。
• 在C++中主要利用new在堆区开辟内存。

#include <iostream>
using namespace std;

int * fun1(){
	// 利用new关键字，将数据开辟到堆区
	// 指针，本质也是局部变量，放在栈上，但是此时，指针保存的数据放在了对上。
	int * p = new int(10);
	return p;
}

int main(){
	
	// 在堆区开辟数据
	int *p = fun1();
	
	cout << *p << endl;

	system("pause");
	return 0;
}

3.new操作符

C++中利用new操作符在堆区开辟数据
堆区开辟的数据，由程序员手动开辟，手动释放，释放利用操作符delete

#include <iostream>
using namespace std;

// new的基本语法
int * fun1(){
	// 在堆区创建整形数据
	// new返回是该数据类型的指针
	int * p = new int(10);
	return p;
}
// 在堆区利用new开辟数组
int * fun2(){
	// 创建10个整形数据的数组，在堆区
	int * arr = new int[10]; // 10代表数组有10个元素，arr接收的是首地址。
	
	for(int i=0; i<10; i++){
		arr[i] = i+100;
	}
}

int main(){
	
	int * p = fun1();
	cout << *p << endl;
	// 堆区的数据由程序员管理开辟，程序员管理释放
	// 如果想释放堆区的数据，利用关键字delete
	delete p;
	cout << *p << endl;
	// 这时，指针p已被释放，不可访问。

	system("pause");
	return 0;
}

2.引用

作用： 给变量起别名。
语法： 数据类型 &别名 = 原名

注意：

• 引用必须初始化。
• 引用初始化后就不可以改变。

2.1引用作函数参数

作用： 函数传参时，可以利用引用的技术让形参修饰实参。
优点： 可以简化指针修改实参。

继值传递、地址传递之后的引用传递。

void mySwap(int &a,int &b){
	int temp = a;
	a = b;
	b = temp;
}
int main(){
	int a = 10;
	int b = 20;
	mySwap(a, b); // 引用传递，形参修饰实参。
}

2.2引用作为函数的返回值

注意： 不要返回局部变量引用。
函数的调用可以作为左值的存在

int & test(){
	int a = 10;
	return a;
}
int & test2(){
	static int a = 10; // 此时，a是静态变量。
	return a;
}

int main(){
	// 局部变量作为返回值，函数运行结束变量被回收。
	int & ref = test();
	cout << "ref= " << ref << endl;  // 此时输出结果为10
	// 函数调用作为左值。如果函数的返回值是引用，这个函数调用可以是左值。
	test2() = 1000;
	cout << "ref= " << ref << endl; // 此时输出结果为1000
}

2.3引用的本质

引用的本质在C++内部实现是一个指针常量。

int main(){
	int a = 10;
	int & ref = a;  // 等价于int * const ref = &a;，指针常量的指针指向不可以改，但是却可以改指向的内容
	ref = 1000;   // 此时就等于  * ref = 1000
	// 这些转换都是自动执行的
	cout << "a=" << a << endl;
	cout << "ref=" << ref << endl;
}

2.4常量引用

void printValue(const int & val){
	val = 1000; // 此时就会报错，因为const修饰，不可以修改数据
	cout << "val=" << val << endl;
}
int main(){
	// 常量引用的使用场景：用来修饰形参，防止误操作
	int a = 10;
	// int &ref = 10; 这是不可以的，会报错
	const int & ref = 10; // 加上const之后，编译器将代码修改：int temp = 10; const int & ref = temp;
	cout << "a=" << a << endl;
	cout << "ref=" << ref << endl;
	printValue(ref);
}

3.函数

3.1函数的默认参数

在C++中，函数的形参列表中的形参是可以有默认值的。
语法：返回值类型 函数名（参数 = 默认值）{}

• 有默认值就可以不传那个对应的值
• 参数列表中，有默认值的在后面，不准把无默认值的参数排在有默认值的参数后面。
• 如果有默认值，但是还是给它传参了，它就用传的参数，不用默认值。
• 如果函数声明有默认参数，函数实现就不能有默认参数。会被编译器认为是重定义默认参数。

3.2函数的占位参数

// 占位参数就是只有个数据类型，不过在调用的时候还必须传参。
// 但是目前用不到，不能调用，后续会学
void func(int a, int){
	cout << "func" << endl;
}
int main(){
	func(10, 1);
}

3.3.函数重载

作用： 函数名可以相同，提高复用性。
函数重载需要满足的条件：

• 同一个作用域下
• 函数名称相同
• 函数参数类型不同，或者个数不同，或者顺序不同

注意： 函数的返回值不可以作为函数重载的条件。

// 引用作为重载的条件,加个const就是重载，满足了参数类型不同
void func(int & a){ // 要接受一个变量
	cout << "func(int & a)调用" << endl;
}
void func(const int & a){ // 要接收一个常量
	cout << "func(const int & a)调用" << endl;
}

// 有默认参数，这两个函数是不构成重载的
void func2(int a, int b = 10){
	cout << "func2(int a, int b = 10)调用" << endl;
}
void func2(int a){
	cout << "func2(int a)调用" << endl;
}

void func(int a, int){
	cout << "func" << endl;
}
int main(){
	func(10, 1);
}

4.类和对象

C++面向对象的三大特征：封装、继承和多态

4.1封装

封装的意义：

• 将属性和行为作为一个整体，表现生活中的事物
• 将属性和行为加以权限控制

#include <iostream>
using namespace std;
// 圆周率
const double PI = 3.14;

// 设计一个圆类，求圆周长

// class 代表设计一个类 ， 类后面紧跟着的就是类名称
class Circle {
public: // 公共权限
	// 类中的属性和行为统一称为成员
	//属性  成员属性  成员变量
	int m_r;

	// 行为  成员函数  成员方法
	// 获取圆的周长
	double calculateZC() {
		return 2 * PI * m_r;
	}

};

class Person {
// 三种访问权限
// 公共权限 public    成员类内可以访问 类外也可以访问
// 保护权限 protected 成员类内可以访问 类外不可以访问 子类可以访问父类中的保护内容
// 私有权限 private   成员类内可以访问 类外不可以访问 子类不可以访问父类中的私有内容
public:
	string name;
	
protected:
	string m_car;
	
private:
	int m_password;

public:
	void func() {
		name = "张三";
		m_car = "摩托";
		m_password = 123456;
	}

};


int main() {

	// 通过圆类创建具体的圆（对象），实例化
	Circle c1;
	// 给圆对象的属性赋值
	c1.m_r = 10;

	cout << "圆c1的周长为：" << c1.calculateZC() << endl;

	Person p1;
	p1.name = "李四"; // 公共权限，在类外可以访问
	p1.m_car = "汽车"; // 保护权限，在类外访问会报错
	p1.m_password = 654321; // 私有权限，在类外访问会报错

	system("pause");
	return 0;
}

struct和class的区别：

• struct默认权限为共有
• class默认权限为私有

将成员属性设置为私有

优点：

• 将所有成员属性设置为私有，可以自己控制读写权限。
• 对于写权限，我们可以检测数据的有效性。

将类单独建立文件

Student.h文件

#pragma once  // 确保文件唯一性
#include <iostream>
using namespace std;

// 学生类
class Student {
public:
	void setName(string n);
	void setID(int i);
	string getName();
	int getID();
	void printIDName();

private:
	int id;
	string name;
};

Student.cpp文件

#include "Student.h"

void Student::setName(string n) {
	name = n;
}
void Student::setID(int i) {
	id = i;
}
string Student::getName() {
	return name;
}
int Student::getID() {
	return id;
}
void Student::printIDName() {
	cout << "姓名: " << name << "\t学号: " << id << endl;
}

主函数的.cpp文件

#include <iostream>
#include <string>
using namespace std;
#include "Student.h"  // 引用头文件

int main() {

	// 通过圆类创建具体的圆（对象）
	Student s1;
	// 给圆对象的属性赋值
	s1.setID(5);
	s1.setName("小明");

	cout << s1.getID() << s1.getName() << endl;


	system("pause");
	return 0;
}

4.2对象的初始化和清理

4.2.1构造函数和析构函数

这两个函数会被编译器自动调用完成初始化和清理工作，如果自己不提供，编译器会提供空的函数并实现。

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

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

• 构造函数没有返回值，并且不用写void
• 函数名称与类名相同
• 构造函数可以有参数，可以重载
• 调用对象会自动调用构造

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

• 析构函数没有返回值，并且不用写void
• 函数名称与类名相同，在名称前加上~
• 不可以有参数，不会发生重载
• 在对象销毁前自动调用

4.2.2构造函数的分类及调用

两种分类方式：

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

三种调用方法：

• 括号法
• 显示法
• 隐式转换法

class Person{
public:
	// 无参构造函数
	Person(){}
	// 有参构造函数
	Person(int a,...){}
	// 拷贝构造函数
	Person(const Person &p){
		// 将传入的人身上的所有属性，都拷贝过来，但是不改变原有的。
	}
	// 析构函数
	~Person(){}
};
// 调用
void func(){
	// 括号法
	Person p1;  // 注意：调用默认构造函数的时候，不要加()
	Person p();  // 这行代码，编译器会认为这是函数的声明，不会认为在创建对象
	Person p2(10);
	Person p3(p2);// 拷贝构造函数
	
	// 显示法
	Person p4;
	Person p5 = Person(10); // 有参构造
	Person p6 = Person(p5); // 拷贝构造函数 
	// Person(10);这是个匿名对象。特点:当前执行结束后，系统会立即回收掉匿名对象
	// 不要利用拷贝构造函数来初始化匿名对象
	Person (p5); // 这个等价于 Person p5; 就会因为重定义报错
	
	// 隐式转换法
	Person p7 = 10; // 相当于： Person p7 = Person(10);
	Person p7 = p6; // 拷贝构造
}

4.2.3拷贝构造函数调用时机

在C++中，拷贝构造函数的调用时机有三个：

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

class Person{
public:
	int m_age;

	// 无参构造函数
	Person(){}
	// 有参构造函数
	Person(int a){
		m_age = a;
	}
	// 拷贝构造函数
	Person(const Person &p){
		// 将传入的人身上的所有属性，都拷贝过来，但是不改变原有的。
		m_age = p.m_age;
	}
	// 析构函数
	~Person(){}
};
// 使用一个已经创建完毕的对象来初始化一个新对象
void func1(){
	Person p1(20);
	Person p2(p1);
	
	cout << "p2的年龄：" << p2.m_age << endl;	
}

// 值传递的方式给函数参数传值
void test1(Person p){
	// 在调用函数test()的时候会拷贝副本，修改副本的值不会影响对象原本的数据
	// 但是在传参的时候确真正的调用了拷贝构造函数构造了一个新的对象。
}
void func2(){
	Person p1;
	test(p1);
}

// 以值方式返回局部对象
Person test2(){
	Person p1; // 创建它的时候会调用构造函数
	return p1; // 返回对象p1，但是它是以值的方式返回对象，这时会调用拷贝构造函数来整出一个新的对象返回给调用这个函数的表达式。
}
void func3(){
	Person p = test2();
}

4.2.4拷贝构造函数调用规则

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

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

构造函数调用规则：

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

4.2.5深拷贝和浅拷贝

• 深拷贝：在堆区内重新申请空间，进行拷贝操作
• 浅拷贝：简单的赋值拷贝操作

class Person{
public:
	int m_age;
	int *m_height;

	// 无参构造函数
	Person(){}
	// 有参构造函数
	Person(int a, int height){
		m_age = a;
		m_height = new int(height);
	}
	// 自己实现拷贝构造函数来解决浅拷贝带来的问题
	// 编译器自动生成的就是浅拷贝
	Person(const Person &p){
		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;	
		}
	}
};
// 使用一个已经创建完毕的对象来初始化一个新对象
void func1(){
	Person p1(12, 180);
	cout << "p1的年龄：" << p1.m_age << "他的身高为：" << *p1.m_height << endl;	
	Person p2(p1);
	
	cout << "p2的年龄：" << p2.m_age << "他的身高为：" << *p2.m_height << endl;	
}

注意：如果属性有自己在堆区开辟的，一定要自己提供一个深拷贝构造函数，自己提供析构函数，没有的话就无所谓了

4.2.6初始化列表

作用： 用来初始化属性
语法：

• 构造函数 （）：属性1（值1），属性2（值2）…{}
• 构造函数 （参数类型1 参数1，参数类型2 参数2）：属性1（参数1），属性2（参数2）…{}

类对象可以作为另一个类的成员

• 那么，先构造作为成员的类的对象，再构造拥有成员类的类的对象。
• 析构的时候恰好相反。

4.2.7静态成员

就是在成员变量或函数前加上static。

静态成员分为：

• 静态成员变量
  • 所有对象共享同一份数据
  • 在编译阶段分配内存
  • 类内声明，类外初始化
• 静态成员函数
  • 所有对象共享同一个函数
  • 静态成员函数只能访问静态成员变量

class Person{
public:
	int m_age;
	int *m_height;

	// 无参构造函数
	Person(){}
	// 有参构造函数
	Person(int a, int height){
		m_age = a;
		m_height = new int(height);
	}
	static void func(){
		cout << "静态函数的调用" << endl;
	}
	
	~Person(){
	}
};

void func1(){
	// 两种访问方式
	// 1.通过对象
	Person p1(12, 180);
	p1.func();
	// 2.通过类名
	Person::func();
}

静态成员函数是有访问权限的，和普通成员一样。

4.3C++对象模型和this指针

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

只有非静态的成员变量才属于某一个对象，静态的成员变量属于所有这个类的所有的对象。

空对象占用内存空间为：1（无成员变量，无成员函数）

• C++编译器会给每个空对象也分配一个字节空间，是为了区分空对象占内存的位置。
• 每个空对象也应该有一个独一无二的内存地址。

对象占内存的大小要看它有多大的非静态成员变量。

4.3.2this指针

this指针的用途：

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

**this指针的本质是一个指针常量，指针的指向不可以修改。

class Person
{
public:
	Person()
	{}

	void personAddAge(Person &p){
		this->age += p.age;
	} 

	Person& personAddAge2(Person &p){
		this->age += p.age;
		// this指向被调用对象的指针，而*this指向的就是这个对象本体
		return *this;
	}

	int age;
};

void test1(){
	Person p1;
	Person p2;
	p1.age = 10;

	p2.personAddAge(p1);
	// p2.personAddAge(p1).personAddAge(p1).personAddAge(p1); // 这段代码就会报错，personAddAge()函数返回的是void，不能继续调用

	p2.personAddAge2(p1).personAddAge2(p1).personAddAge2(p1); // 这就不会报错，因为personAddAge2()函数返回的是p2对象本身，可以继续。

}

4.3.3空指针访问成员函数

class Person
{
public:
	void showClassName()
	{
		cout << "this is Person class" << endl;
	}

	void showPersonAge()
	{
		if(this == NULL) // 提高代码健壮性，防止空指针调用。
		{
			return;
		}
		cout << "age = " << this->age << endl;
	}

	int age;
};

void test1()
{
	Person p1 = NULL;

	// 完全可以正常运行，因为不需要用任何成员变量
	p1.showClassName();

	p1.showPersonAge();

}

4.3.4const修饰成员函数

常函数：

• 成员函数后加上const后我们称这个函数为常函数。
• 常函数内不可以修改成员属性。
• 成员属性声明时加关键字mutable后，常函数就可以修改成员属性。

常对象：

• 声明对象前加const则称该对象为常对象。
• 常对象只能调用常函数。

class Person
{
public:
	// 在成员函数后面加上const，实际上修饰的是this指向，让指针指向的值也不可以修改。
	void showPersonAge() const
	{
		this->age = 100; // 被const修饰，此函数已经是常函数了，不可以修改未被关键字mutable修饰的成员属性。
		cout << "age = " << this->age << endl;
	}

	void showPersonName() const
	{
		this->name = "狗蛋"; // 被const修饰，此函数已经是常函数了，但是被关键字mutable修饰了的成员属性，可以被修改。
		cout << "name = " << this->name << endl;
	}
	
	void test()
	{
	}
	
	int age;
	mutable string name;
};

void test1()
{
	const Person p1; // 在对象前加const，变为常对象。

	p1.age = 100; // 常对象不可以修改成员属性
	p1.name = "狗娃"; // 被mutable修饰的成员属性可以被常对象修改。
	// 常对象只能调用常函数
	p1.showPersonName();
	p1.test(); // 不允许调用不是常函数的函数。
	
}

4.4友元

友元的目的： 让一个类或函数访问另一个类中的私有成员。
友元关键字：friend
友元的三种实现：

• 全局函数做友元
• 类做友元
• 成员函数做友元

4.4.1全局函数做友元

class Building
{
	// goodGay()全局函数是Building的好朋友，可以访问Building中的私有成员。
	friend void goodGay(Building *building);
	// GoodGay类是本类的好朋友，可以访问本类的私有成员。
	friend class GoodGay;
	// 告诉编译器 GoodGay类下的 visit函数是Building类的好朋友，可以访问本类的私有成员。
	friend void GoodGay::visit();
	
public:
	Building();

public:
	string m_SittingRoom;  // 客厅
private:
	string m_BedRoom;  // 卧室
};
// 类外写成员函数
Building::Building()
{
	m_SittingRoom = "客厅";
	m_BedRoom = "卧室";
}
GoodGay::GoodGay()
{
	// 创建建筑物对象
	building = new Building;
}


// 类做友元
class GoodGay
{
public:
	void visit(); // 参观函数，访问Building的属性。
	Building *building;	
};
// 类外写成员函数
void GoodGay::visit()
{
}


// 全局函数
void goodGay(Building *building)
{
	
}

4.5运算符重载

运算符重载概念： 对已有的运算符进行重新定义，赋予其另一种功能，以适应不同的数据类型。
运算符重载也会发生函数重载
总结：

• 对于内置的数据类型的表达式的运算符是不可能改变的
• 不要滥用运算符重载

4.5.1加号运算符重载

class Person
{
public:
	int m_A;
	int m_B;

	// 成员函数重载加号
	Person operator+(Person &p)
	{
		Person temp;
		temp.m_A = this->m_A + p.m_A;
		temp.m_B = this->m_B + p.m_B;
		return temp;
	}

};

// 全局函数重载加号
Person operator+(Person &p1, Person &p2)
{
	Person temp;
	temp.m_A = p1.m_A + p2.m_A;
	temp.m_B = p1.m_B + p2.m_B;
	return temp;
}
// 运算符重载引发的函数重载
Person operator+(Person &p1, int num)
{
	Person temp;
	temp.m_A = p1.m_A + num;
	temp.m_B = p1.m_B + num;
	return temp;
}

void test()
{
	Person p1;
	Person p2;
	p1.m_A = 10;
	p1.m_B = 10;
	p2.m_A = 10;
	p2.m_B = 10;
	Person p3 = p1.operator+(p2);
	// 上面的与下面的作用一样
	Person p3 = p1 + p2;
	// 全局函数重载
	Person p3 = operator+(p1, p2);
	Person p3 = p1 + p2;
	// 运算符重载引发的函数重载
	Person p4 = p1 + 10;
}

4.5.2左移运算符重载

通常不会使用成员函数来重载它，因为无法保证cout在左侧

class Person
{
public:
	int m_A;
	int m_B;
};

// 都是使用全局函数来重载左移运算符
ostream & operator<<(ostream &cout, Person &p)
{ // 这里要返回cout才可以继续链式编程的方式在后面加上 << endl 
	cout << "m_A = " << p.m_A << "m_B = " << p.m_B;
	return cout;
} 

void test()
{
	Person p1;
	cout << p1 << endl;
}

4.5.3递增运算符重载

作用： 通过重载递增运算符，实现自己的整型数据。

class MyInteger
{
public:
	MyInteger()
	{
		m_Num = 0;
	}
	// 重载前置++运算符
	MyInteger & operator++()
	{ // 这里一定要返回引用，目的是一直对一个数据进行操作
		// 先进行++运算
		m_Num++;
		// 后返回自身
		return *this;
	}

	// 重载后置++运算符
	MyInteger operator++(int) // int代表占位参数，用于区分前置还是后置
	{ // 这里返回值，是因为temp会在函数调用完成被清空
		// 先记录当前的结果
		MyInteger temp = *this;
		// 后递增
		m_Num++;
		// 最后将记录结果做返回
		return temp;
	}

private:
	int m_Num;
};
void test()
{
	MyInteger i;
	
}

4.5.4赋值运算符重载

c++编译器至少给一个 类添加4个函数

• 默认构造函数
• 默认析构函数
• 默认拷贝构造函数，对属性进行值拷贝
• 赋值运算符operator=，对属性进行值拷贝

如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝的问题。

class Person
{
public:
	int *m_Age;

	Person(int age)
	{
		m_Age = new int(age);	
	}

	~Person()
	{
		if(m_A != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
	}

	Person & operator=(Person &p)
	{
		if(m_A != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
		m_Age = new int(*p.m_Age)
		return *this;
	}

};

void test()
{
	Person p1(20);
	Person p2(18);
	Person p3(30);
	p3 = p1 = p2;
	cout << *p1.m_Age << endl;
	cout << *p2.m_Age << endl;
	cout << *p3.m_Age << endl;
}

4.5.5关系运算符重载

作用： 重载关系运算符，可以让两个自定义类型对象进行对比操作。

class Person
{
public:
	int m_Age;
	string m_Name;

	Person(int age, string name)
	{
		m_Age = age;
		m_Name = name;	
	}

	// 重载==
	bool operator==(Person &p){
		if(this->m_Age == p.m_Age)
		{
			return true;	
		}
		return false;
	}

	// 重载!=
	bool operator!=(Person &p){
		if(this->m_Name == p.m_Name)
		{
			return false;
		}
		return true;
	}

	~Person()
	{
		
	}

};

void test(){
	Person p1(14, "小王");
	Person p2(16, "小赵");
	if(p1 == p2){
		cout << p1.m_Name << "的年龄与" << p2.m_Name << "的年龄相等" << endl;
	}
	else
	{
		cout << p1.m_Name << "的年龄与" << p2.m_Name << "的年龄不相等" << endl;
	}
	if(p1 != p2){
		cout << p1.m_Name << "的姓名与" << p2.m_Name << "的姓名不一样" << endl;
	}
	else
	{
		cout << p1.m_Name << "的姓名与" << p2.m_Name << "的姓名一样" << endl;
	}
}

4.5.6函数调用运算符

• 函数调用运算符（）也可以重载。
• 由于重载后使用的方式非常类似函数的调用，因此称为仿函数。
• 仿函数没有固定写法，非常灵活。

class MyPrint
{
public:	
	// 重载函数调用运算符
	void operator()(string test){
		cout << test << endl;
	}

};

void test()
{
	MyPrint myPrint;
	myPrint("hello world");
	// 匿名函数对象
	MyPrint()("hello world");
}

4.6继承

语法：class 子类 ：继承方式 父类

子类也称为派生类，父类也称为基类。

好处：可以减少重复的代码。

4.6.1继承的方式

• 公共继承
• 保护继承
• 私有继承

Class A
{
public:
	int a;
protected:
	int b;
private:
	int c;
};
// 公共继承
Class B : public A
{
public:
	int a;
protected:
	int b;
不可访问:
	int c;
};
// 保护继承
Class C : protected A
{
protected:
	int a;
	int b;
不可访问:
	int c;
};
// 私有继承
Class D : private A
{
private:
	int a;
	int b;
不可访问:
	int c;
};

父类中所有的非静态成员属性都会被子类继承下去，虽然父类中的私有成员属性访问不到，但是只是被编译器隐藏了，但是确实被继承下来了，所以子类对象大小要算子类本身的非静态成员属性与父类非静态成员属性和。

利用开发人员命令提示工具查看对象模型：
	跳转盘符
	跳转到具体路径下
	查看命令
	cl /d1 reportSingleClassLayout类名  文件名

子类继承父类后，当创建子类对象，也会调用父类的构造函数。
子类与父类构造函数、析构函数的调用顺序： 先父类构造，后子类构造、子类析构，最后父类析构。

4.6.2继承中同名成员处理方法

问题： 子类与父类出现同名的成员，如何通过子类对象访问到子类或父类中同名的数据呢？

• 访问子类同名成员 直接访问即可
• 访问父类同名成员 需要加作用域

class Base
{
public:
	Base()
	{
		m_A = 100;
	}

	void func()
	{
		cout << "Base func()" << endl;	
	}

	int m_A;
	
};

class Son:public Base
{
public:
	Son()
	{
		m_A = 200;
	}

	void func()
	{
		cout << "Son func()" << endl;	
	}

	int m_A;

};

void test()
{
	Son s;
	// 调用子类自身的   结果为：200
	cout << "m_A = " << s.m_A << endl;
	// 调用父类的（要加作用域）  结果为：100
	cout << "m_A = " << s.Base::m_A << endl;

	s.func(); // 调用子类的同名方法
	s.Base::func(); // 调用父类的同名方法
}

问题： 继承中同名的静态成员在子类中如何访问？

• 访问子类同名成员 直接访问即可
• 访问父类同名成员 需要加作用域

class Base
{
public:
	static void func()
	{
		cout << "Base func()" << endl;	
	}

	static int m_A;
	
};
int Base::m_A = 100;

class Son:public Base
{
public:
	static void func()
	{
		cout << "Son func()" << endl;	
	}

	static int m_A;

};
int Son::m_A = 200;

void test()
{
	// 1.通过对象访问数据
	Son s;
	cout << "m_A = " << s.m_A << endl;
	cout << "m_A = " << s.Base::m_A << endl;
	// 2.通过类名访问数据
	cout << "m_A = " << Son::m_A << endl;
	// 第一个::代表通过类名的方式来访问  第二个::表示访问父类作用域下
	cout << "m_A = " << Son::Base::m_A << endl;

	// 1.通过对象访问
	s.func(); // 调用子类的同名方法
	s.Base::func(); // 调用父类的同名方法
	// 1.通过类名访问
	Son::func();
	Son::Base::func();
}

4.6.3多继承

语法： class 子类 ：继承方式 父类1，继承方式 父类2…

多继承可能会引发父类中有同名成员出现，需要加作用域区分，在实际开发中不建议使用。

4.6.4菱形继承

• 两个派生类继承同一个基类
• 又有某个类同时继承这两个派生类
• 这就是菱形继承或钻石继承

有的数据只要一份就可以了，菱形继承会导致数据产生两份，资源浪费。

在两个派生类继承基类时，在继承方式前加上关键字virtual 变为虚继承就不会产生两份数据了。
基类也就成了虚基类

4.7多态

4.7.1多态的基本概念

多态分为两类：

• 静态多态：函数重载和运算符重载属于静态多态，复用函数名。
• 动态多态：派生类和虚函数实现运行时多态。

静态多态和动态多态的区别：

• 静态多态的函数地址早绑定 - 编译阶段确定函数地址。
• 动态多态的函数地址晚绑定 - 运行阶段确定函数地址。

class Animal
{
public:
	// 加了virtual关键字后，这个函数变成了虚函数
	virtual void speak() {
		cout << "动物在叫" << endl;
	}

};

class Cat : public Animal
{
public:
	// 重写：函数返回值类型，函数名，参数列表完全相同
	virtual void speak() {
		cout << "小猫在叫" << endl;
	}

};

// 地址早绑定  在编译阶段确定函数地址
// 如果想要执行猫叫 那么这个函数地址就不能提前绑定，需要在运行阶段进行绑定，地址晚绑定
// 动态多态的使用
// 父类的指针或者引用 执行子类对象
void doSpeak(Animal &animal) {
	animal.speak();
}

void test() {
	Cat cat;
	doSpeak(cat);
}

动态多态满足的条件：

1. 有继承关系
2. 子类重写父类的 虚函数

vfptr：虚函数（表）指针

• v - virtual
• f - function
• ptr - pointer

vftable：虚函数表

• v - virtual
• f - function
• table - table

当父类的指针或者引用指向子类对象时，发生多态。

// 分别利用普通写法和多态技术实现计算机
// 普通写法
class Calculator
{
public:

	int getResult(string oper) {
		if (oper == "+") {
			return m_Num1 + m_Num2;
		}
		else if (oper == "-") {
			return m_Num1 - m_Num2;
		}
		else if (oper == "*") {
			return m_Num1 * m_Num2;
		}
	}
	// 开闭原则：对扩展进行开放，对修改进行关闭

	int m_Num1;
	int m_Num2;

};

// 利用多态实现计算器
// 多态的好处
// 1.组织结构清晰
// 2.可读性强
// 3.对于前期或后期的扩展以及维护性高
// 实现计算器的抽象类
class AbstractCalculator 
{
public:
	virtual int getResult() {
		return 0;
	}

	int m_Num1;
	int m_Num2;

};

// 加法计算器类
class AddCalculator :public AbstractCalculator
{
public:
	int getResult() {
		return m_Num1 + m_Num2;
	}

};
// 减法计算器类
class SubCalculator :public AbstractCalculator
{
public:
	int getResult() {
		return m_Num1 - m_Num2;
	}

};
// 乘法计算器类
class MulCalculator :public AbstractCalculator
{
public:
	int getResult() {
		return m_Num1 * m_Num2;
	}

};

void test01() {
	Calculator *c = new Calculator;
	c->m_Num1 = 10;
	c->m_Num2 = 20;
	cout << "加法：" << c->getResult("+") << endl;
	cout << "减法：" << c->getResult("-") << endl;
	cout << "乘法：" << c->getResult("*") << endl;
	delete c;
}

void test02() {
	AbstractCalculator* a = new AddCalculator;
	a->m_Num1 = 10;
	a->m_Num2 = 20;
	cout << "加法：" << a->getResult() << endl;
	delete a;

	AbstractCalculator* b = new SubCalculator;
	b->m_Num1 = 10;
	b->m_Num2 = 20;
	cout << "减法：" << b->getResult() << endl;
	delete b;
	
	AbstractCalculator* c = new MulCalculator;
	c->m_Num1 = 10;
	c->m_Num2 = 20;
	cout << "乘法：" << c->getResult() << endl;
	delete c;

}

4.7.2纯虚函数和抽象类

在多态中，通常父类中虚函数的实现是毫无意义的，主要调用子类重写的内容，因此可将虚函数写为纯虚函数。
纯虚函数语法：virtual 返回值类型 函数名（参数列表）= 0 ；

抽象类： 类中有了纯虚函数

抽象类特点：

• 无法实例化对象
• 子类必须重写抽象类中的纯虚函数，否则也是抽象类

4.7.3虚析构和纯虚析构

在多态中，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的代码。

• 解决方法：将父类中的析构函数改为虚析构或者纯虚析构。

虚析构和纯虚析构共性：

• 可以解决父类指针释放子类对象
• 都需要有具体的函数实现

虚析构和纯虚析构的区别：

• 如果是纯虚析构，该类属于抽象类，无法实例化对象

class Base
{
public:
	// 虚析构，就不用在类外实现
	virtual ~Base(){}
	// 纯虚析构
	virtual ~Base() = 0;
};
// 纯虚析构也需要在类外实现，然而它的子类不会重写它的析构函数，所以就需要直接在外面实现一下
// 有了纯虚析构后，这个类也属于抽象类，无法实例化对象
Base::~Base()
{}

总结：

1. 虚析构或者纯虚析构就是用来解决通过父类指针释放子类对象
2. 如果子类中没有堆区数据，可以不写虚析构或者纯虚析构
3. 拥有纯虚析构函数的类也属于抽象类

电脑组装的案例

描述：

1. 电脑主要组成部件为CPU，显卡，内存条
2. 每个零件封装出抽象基类，并且提供不同的厂商生产不同的零件
3. 创建电脑类，提供让电脑工作的函数，并且调用每个零件工作的接口
4. 测试时组装三台不同的电脑进行工作

#include <iostream>
using namespace std;


// 先抽象出每个零件的类
class CPU {
public:
	virtual void calculate() = 0;
};

class VideoCard {
public:
	virtual void display() = 0;
};

class Memory {
public:
	virtual void storage() = 0;
};

// 电脑类
class Computer {
	// 构造函数中传入三个零件指针
private:
	CPU* m_Cpu;
	VideoCard* m_VideoCard;
	Memory* m_Memory;
	
public:
	// 提供构造函数
	Computer(CPU *cpu,VideoCard *videoCard, Memory * memory) {
		m_Cpu = cpu;
		m_VideoCard = videoCard;
		m_Memory = memory;

	}

	// 提供工作的函数
	void doWork() {
		// 让零件工作起来，调用他们自己的接口
		m_Cpu->calculate();

		m_VideoCard->display();
		
		m_Memory->storage();
	}

	// 提供析构函数释放电脑的零件
	~Computer() {
		if (m_Cpu != NULL)
		{
			delete m_Cpu;
			m_Cpu = NULL;
		}
		if (m_VideoCard != NULL)
		{
			delete m_VideoCard;
			m_VideoCard = NULL;
		}
		if (m_Memory != NULL)
		{
			delete m_Memory;
			m_Memory = NULL;
		}
	
	}

};

// 具体零件厂商
// 因特尔公司
class IntelCPU :public CPU
{
public:
	virtual void calculate() {
		cout << "IntelCPU开始计算了" << endl;
	}

};
class IntelVideoCard :public VideoCard
{
public:
	virtual void display() {
		cout << "IntelVideoCard开始显示了" << endl;
	}

};
class IntelMemory :public Memory
{
public:
	virtual void storage() {
		cout << "IntelMemory开始存储了" << endl;
	}

};

// 联想公司
class LenovoCPU :public CPU
{
public:
	virtual void calculate() {
		cout << "LenovoCPU开始计算了" << endl;
	}

};
class LenovoVideoCard :public VideoCard
{
public:
	virtual void display() {
		cout << "LenovoVideoCard开始显示了" << endl;
	}

};
class LenovoMemory :public Memory
{
public:
	virtual void storage() {
		cout << "LenovoMemory开始存储了" << endl;
	}

};


// 开始组装不同的电脑
void test01() {
	// 纯Intel厂商的电脑
	CPU *c = new IntelCPU;
	VideoCard* vc = new IntelVideoCard;
	Memory* m = new IntelMemory;

	Computer* p = new Computer(c, vc, m);

	p->doWork();
	delete p;
}

void test02() {
	// 纯Lenovo厂商的电脑
	Computer* p = new Computer(new LenovoCPU, new LenovoVideoCard, new LenovoMemory);

	p->doWork();
	delete p;
}

void test03() {
	// 组装的电脑
	CPU* c = new IntelCPU;
	VideoCard* vc = new LenovoVideoCard;
	Memory* m = new LenovoMemory;

	Computer* p = new Computer(c, vc, m);

	p->doWork();
	delete p;
}


int main()
{
	// 第一台电脑
	test01();

	// 第二台电脑
	test02();

	// 第三台电脑
	test03();


	system("pause");
	return 0;
}

5.文件操作

通过文件将数据持久化
需要头文件：< fstream>

文件类型分为两种：

1. 文本文件：文件以文本的ASCII码形式存储在计算机中。
2. 二进制文件：文件以文本的二进制形式存储在计算机中，用户一般不能读懂他们。

操作文件的三大类：

• ofstream：写操作
• ifstream：读操作
• fstream：读写操作

文件打开方式：

打开方式	解释
ios::in	为读文件而打开文件
ios::out	为写文件而打开文件
ios::ate	初始位置：文件尾
ios::app	追加方式：写文件
ios::trunc	如果文件存在：先删除，再创建
ios::binary	二进制方式

注意： 文件打开方式可以多个配合使用：利用 | 操作符。

文本文件

写文件

步骤：

1. 包含头文件：#include < fstream>
2. 创建流对象：ofstream ofs；
3. 打开文件：ofs.open(“文件路径”，“打开方式”)；
4. 写数据：ofs << “写入的数据”；
5. 关闭文件：ofs.close()；

读文件

步骤：

1. 包含头文件：#include < fstream>
2. 创建流对象：ifstream ifs；
3. 打开文件：ifs.open(“文件路径”，“打开方式”)；
4. 读数据：四种方式读取
5. 关闭文件：ifs.close()；

注： 判断文件是否打开成功，ifs.is_open()，如果打开成功返回true，失败返回false。

四种读取方式：

// 第一种
char buf[1024] = { 0 };
while(ifs >> buf)
{
	// 一次读一行或者1024个字节
	cout << buf << endl;
}

// 第二种
char buf[1024] = { 0 };
while(ifs.getline(buf, sizeof(buf)))
{
	// 一次读一行或者1024个字节
	cout << buf << endl;
}

// 第三种
string buf;
while(getline(ifs, buf))
{
	// 一次读一行
	cout << buf << endl;
}

// 第四种
char c;
while((c = ifs.get()) != EOF)
{
	// 一次读一个字节,直到读到文件尾（EOF表示文件尾）
	cout << c;
}

二进制文件

写文件，步骤与文本文件的类似

write函数原型： ostream& write(const char* buffer, int len)；

// 打开文件
ofstream ofs("test.txt", ios::out | ios::binary);
// 写文件
Person p = {"张三", 18};
// 这里需要取地址并且强转为const char *格式的数据
ofs.write((const char *)&p, sizeof(Person));
// 关闭
ofs.close();

读文件，步骤与文本文件的类似

read函数原型： istream& read(char *buffer, int len)；

// 打开文件
ifstream ifs("test.txt", ios::in | ios::binary);
// 判断是否打开
if(!ifs.is_open())
{
	cout << "文件打开失败!!!" << endl;
	return;
}
// 写文件
Person p;
// 这里需要取地址并且强转为const char *格式的数据
ifs.read((char *)&p, sizeof(Person));
// 关闭
ifs.close();