c++核心--类和对象

# 类和对象

面向对象的三大特性: 封装、继承、多态

# 1. 封装

# 1.1 封装的意义：

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

封装意义一：在设计类的时候，属性和行为写在一起，表现事物
语法： class 类名{ 访问权限： 属性 / 行为 };

封装意义二：类在设计时，可以把属性和行为放在不同的权限下，加以控制访问权限有三种：

• public 公共权限
• protected 保护权限
• private 私有权限

struct 和 class 的区别：

• struct 默认权限是 公共 public
• class 默认权限是 私有 private

# 1.2 成员属性设置为私有

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

# 2. 对象的初始化和清理

# 2.1 构造函数和析构函数

构造函数和析构函数将会被编译器自动调用，完成对象初始化和清理工作。如果我们不提供构造和析构，编译器会提供
编译器提供的构造函数和析构函数是空实现。
构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。
析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作。

构造函数语法： 类名(){}

1. 构造函数，没有返回值也不写 void
2. 函数名称与类名相同
3. 构造函数可以有参数，因此可以发生重载
4. 程序在调用对象时候会自动调用构造，无须手动调用，而且只会调用一次

析构函数语法： ~类名(){}

1. 析构函数，没有返回值也不写 void
2. 函数名称与类名相同，在名称前加上符号～
3. 析构函数不可以有参数，因此不可以发生重载
4. 程序在对象销毁前会自动调用析构，无须手动调用，而且只会调用一次

# 2.2 构造函数的分类及其调用

两种分类方式：

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

三种调用方式：

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

#include<iostream>

#include<string>

using namespace std;


// 构造函数的分类及调用

//分类


class Person {

public:

        int age;

        Person() {

               cout << "无参数构造" << endl;

        }



        Person(int a) {

               age = a;

               cout << "有参数构造" << endl;

        }



        // 拷贝构造函数

        Person(const Person &p) {

               //将传入的人身上的所有属性，拷贝到我身上

               age = p.age;

               cout << "拷贝构造函数" << endl;

        }

        ~Person() {

               cout << "析构函数" << endl;

        }

};



//调用

void test1() {
        //1. 括号法
        Person p1;     //默认构造函数调用，
        //注意调用构造函数时不要加上（），加上括号，编译器会认为这是一个函数的声明
        Person p2(10); //有参数构造函数
        Person p3(p2); //拷贝构造函数
        cout << "p2's age = " << p2.age << endl;
        cout << "p3's age = " << p3.age << endl;

        //2. 显示法
        Person p4;//默认构造函数调用，
        Person p5 = Person(10);//有参数构造函数
        Person p6 = Person(p5);//拷贝构造函数
        Person(10);//匿名对象，当前行执行完，系统会立刻回收，马上析构
        //2.3 隐式转换法
        Person p7 = 10; // Person p7 = Person(10); 
       Person p8 = p7; // Person p8 = Person(p7); 
        //注意2：不能利用 拷贝构造函数 初始化匿名对象 编译器认为是对象声明
        //Person p5(p4);
}


int main() {
        test1();
        system("pause");
        return 0;
}

# 2.3 拷贝构造函数调用时机

C++ 中拷贝构造函数调用时机通常有三种情况

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

class Person {
public:
	Person() {
		cout << "无参构造函数!" << endl;
		mAge = 0;
	}
	Person(int age) {
		cout << "有参构造函数!" << endl;
		mAge = age;
	}
	Person(const Person& p) {
		cout << "拷贝构造函数!" << endl;
		mAge = p.mAge;
	}
	//析构函数在释放内存之前调用
	~Person() {
		cout << "析构函数!" << endl;
	}
public:
	int mAge;
};

//1. 使用一个已经创建完毕的对象来初始化一个新对象
void test01() {

	Person man(100); //p对象已经创建完毕
	Person newman(man); //调用拷贝构造函数
	Person newman2 = man; //拷贝构造

	//Person newman3;
	//newman3 = man; //不是调用拷贝构造函数，赋值操作
}

//2. 值传递的方式给函数参数传值
//相当于Person p1 = p;
void doWork(Person p1) {}
void test02() {
	Person p; //无参构造函数
	doWork(p);
}

//3. 以值方式返回局部对象
Person doWork2()
{
	Person p1;
	cout << (int *)&p1 << endl;
	return p1;
}

void test03()
{
	Person p = doWork2();
	cout << (int *)&p << endl;
}


int main() {

	//test01();
	//test02();
	test03();

	system("pause");

	return 0;
}

# 2.4 构造函数调用规则

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

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

构造函数调用规则如下：

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

# 2.5 深拷贝和浅拷贝（面试经典问题）

浅拷贝：简单的赋值拷贝操作；如果利用编译器提供的拷贝构造函数，就会进行浅拷贝
深拷贝：在堆区重新申请空间，进行拷贝操作；若自己写，可利用 new 进行深拷贝

浅拷贝的问题：会带来堆区的内存重复释放
解决方法：使用深拷贝

#include<iostream>

#include<string>



using namespace std;



// 深拷贝和浅拷贝



class Person {

public:

        int age;

        int *height;//设计为指针，是为了把height开辟在堆区



        Person() {

               cout << "无参数构造" << endl;

        }



        Person(int a, int h) {

               age = a;

               height= new int(h);//把身高开辟在堆区

               cout << "有参数构造" << endl;

        }



        // 拷贝构造函数  

        Person(const Person& p) {

               cout << "拷贝构造函数!" << endl;

               //如果不利用深拷贝在堆区创建新内存，会导致浅拷贝带来的重复释放堆区问题

               age = p.age;

               // height = p.height; // 这就是编译器自动进行的浅拷贝

               height = new int(*p.height);  //使用new，在堆区新开辟一个空间



        }



        ~Person() {

               //将堆区开辟的数据做释放操作

               if (height != NULL)

               {

                       delete height;

               }

               cout << "析构函数" << endl;

        }

};



void test01() {

        Person p1(18, 160);

        cout << "p1's age =" << p1.age << endl;

        cout << "p1's height =" << *p1.height << endl;



        Person p2(p1);

        cout << "p2's age =" << p2.age << endl;

        cout << "p2's height =" << *p2.height << endl;

}


int main() {

        test01();

        system("pause");

        return 0;

}

注意：当成功编写拷贝构造函数，但在 vs 里面运行失败，原因在于没有把其他 cpp 文件注释
总结：如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题

# 2.6 初始化列表

作用：C++ 提供了初始化列表语法，用来初始化属性
语法： 构造函数()：属性1(值1),属性2（值2）... {}
上述语法固定了初始化的值，若想改变，则需要按照下法处理

class Person {

public:

        int a, b, c;

        //初始化列表，可随时改变值

        Person(int aa, int bb, int cc) :a(aa), b(bb), c(cc)

        {  }

};

# 2.7 类对象作为类成员

class A{}
class B{
    A b;//
}

当类 A 对象作为 B 中一个成员时，创建对象时，会

• 先构造 A 再构造 B
• 先析构 B 在析构 A

# 2.8 静态成员

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

• 静态成员变量

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

静态成员变量也有访问权限；
静态成员变量可以通过对象访问（ 对象名.静态成员变量 ）或者通过类名访问（ 类名::静态成员变量 ）

class Person
{
	
public:
	static int m_A; //静态成员变量
private:
	static int m_B; //静态成员变量也是有访问权限的
};
//类外初始化的方法
int Person::m_A = 10;
int Person::m_B = 10;//私有变量无法类外访问

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

	//1、通过对象
	Person p1;
	p1.m_A = 100;
	cout << "p1.m_A = " << p1.m_A << endl;//输出100

	Person p2;
	p2.m_A = 200;
	cout << "p1.m_A = " << p1.m_A << endl; //共享同一份数据，200
	cout << "p2.m_A = " << p2.m_A << endl;//输出200

	//2、通过类名
	cout << "m_A = " << Person::m_A << endl;//200
	//cout << "m_B = " << Person::m_B << endl; //私有权限访问不到
}

int main() {
	test01();
	system("pause");
	return 0;
}

• 静态成员函数

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

访问方式：1 通过对象 (.) 2 通过类名 ( :: )
静态成员函数也有访问权限；

# 3. C++ 对象模型和 this 指针

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

• 在 C++ 中，类内的成员变量和成员函数分开存储

• 只有非静态成员变量才属于类的对象上，占用内存空间；静态成员变量和（静态 & 非静态）成员函数都不属于类的对象，不占用内存空间。

• 空对象占用内存空间为 1，也有自己独一无二的内存地址

# 3.2 this 指针

在 C 中成员变量和成员函数是分开存储的，每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码
那么问题是：这一块代码是如何区分那个对象调用自己的呢？c 通过提供特殊的对象指针，this 指针，解决上述问题。

this 指针指向被调用的成员函数所属的对象 this 指针是隐含每一个非静态成员函数内的一种指针

this 指针不需要定义，直接使用即可

this 指针的用途：

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

class Person
{
public:

	Person(int age)
	{
		//1、当形参和成员变量同名时，可用this指针来区分,，第一个age才是类内定义的age，第二个age是传来的参数副本
		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;
}

# 3.3 空指针访问成员函数

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

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

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

void ShowPerson() {
		if (this == NULL) {
			return;
		}
		cout << mAge << endl;
	}

# 3.4 const 修饰成员函数

常函数：

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

常对象：

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

class Person {
public:
	Person() {
		m_A = 0;
		m_B = 0;
	}

	//this指针的本质是一个指针常量，指针的指向不可修改
	//如果想让指针指向的值也不可以修改，需要声明常函数
	void ShowPerson() const {
		//const Type* const pointer;
		//this = NULL; //不能修改指针的指向 Person* const this;
		//this->mA = 100; //但是this指针指向的对象的数据是可以修改的

		//const修饰成员函数，表示指针指向的内存空间的数据不能修改，除了mutable修饰的变量
		this->m_B = 100;
	}

	void MyFunc() const {
		//mA = 10000;
	}

public:
	int m_A;
	mutable int m_B; //可修改 可变的
};


//const修饰对象  常对象
void test01() {

	const Person person; //常量对象  
	cout << person.m_A << endl;
	//person.mA = 100; //常对象不能修改成员变量的值,但是可以访问
	person.m_B = 100; //但是常对象可以修改mutable修饰成员变量

	//常对象访问成员函数
	person.MyFunc(); //常对象不能调用const的函数

}

# 4. 友元

友元的目的就是让一个函数或者类 访问另一个类中私有成员

友元的关键字为 friend
友元的三种实现

1. 全局函数做友元

//告诉编译器 goodGay全局函数 是 Building类的好朋友，可以访问类中的私有内容
	friend void goodGay(Building * building);

2. 类做友元

//告诉编译器 goodGay类是Building类的好朋友，可以访问到Building类中私有内容
	friend class goodGay;

3. 成员函数做友元

//告诉编译器  goodGay类中的visit成员函数 是Building好朋友，可以访问私有内容
	friend void goodGay::visit();

# 5. 运算符重载

概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型
注意：对于内置的数据类型的表达式的的运算符是不可能改变的

# 5.1 加号运算符重载

方法：

• 成员函数
• 全局函数

//成员函数实现 + 号运算符重载
	Person operator+(const 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 p3 = p2 + p1;  //相当于 p2.operaor+(p1)

//全局函数实现 + 号运算符重载
Person operator+(const Person& p1, const Person& p2) {
	Person temp(0, 0);
	temp.m_A = p1.m_A + p2.m_A;
	temp.m_B = p1.m_B + p2.m_B;
	return temp;
}
Person p3 = p2 + p1;  //相当于 operaor+(p1,p2)

//全局函数
//运算符重载 可以发生函数重载 
Person operator+(const Person& p2, int val)  
{
	Person temp;
	temp.m_A = p2.m_A + val;
	temp.m_B = p2.m_B + val;
	return temp;
}
Person p4 = p3 + 10; //相当于 operator+(p3,10)

# 5.2 左移运算符重载

方式：只有全局函数才可以，成员函数无法达到我们的期望

//成员函数：
//本质p.operator<<(cout)  简化版本p<<cout，不满足我们的期望
        void operator<<(cout) {}

//只能利用全局函数重载左移运算符
//本质operator<<(cout， p)  简化版本cout<<p，符合要求
//ostream对象只能有一个
ostream& operator<<(ostream& out, Person& p) {
	out << "a:" << p.m_A << " b:" << p.m_B;
	return out;
}
//链式编程思想，定义返回的类型为ostream&，则cout << p后还是一个cout，可以继续加endl
   cout << p << endl;

# 5.3 递增运算符重载

深浅拷贝问题
c++ 编译器至少给一个类添加 4 个函数

• 默认构造函数 (无参，函数体为空)
• 默认析构函数 (无参，函数体为空)
• 默认拷贝构造函数，对属性进行值拷贝
• 赋值运算符 operator=, 对属性进行值拷贝

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

class Person
{
public:

	Person(int age)
	{
		//将年龄数据开辟到堆区
		m_Age = new int(age);
	}

	//重载赋值运算符 
	Person& operator=(Person &p)
	{
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
		//编译器提供的代码是浅拷贝
		//m_Age = p.m_Age;

		//提供深拷贝 解决浅拷贝的问题
		m_Age = new int(*p.m_Age);

		//返回自身
		return *this;
	}


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

	//年龄的指针
	int *m_Age;

};


void test01()
{
	Person p1(18);
	Person p2(20);
	Person p3(30);

	p3 = p2 = p1; //赋值操作
    
	cout << "p1的年龄为：" << *p1.m_Age << endl;
    cout << "p2的年龄为：" << *p2.m_Age << endl;
	cout << "p3的年龄为：" << *p3.m_Age << endl;
}

int main() {
	test01();
	system("pause");
	return 0;
}

# 5.5 函数调用运算符重载

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

class MyPrint
{
public:
	void operator()(string text)
	{
		cout << text << endl;
	}

};
void test01()
{
	//重载的（）操作符 也称为仿函数
	MyPrint myFunc;
	myFunc("hello world");
}


class MyAdd
{
public:
	int operator()(int v1, int v2)
	{
		return v1 + v2;
	}
};

void test02()
{
	MyAdd add;
	int ret = add(10, 10);
	cout << "ret = " << ret << endl;

	//匿名对象调用  
	cout << "MyAdd()(100,100) = " << MyAdd()(100, 100) << endl;
}

# 6. 继承

# 6.1 继承的基本语法

优点： 减少重复代码
语法： class A : 继承方式 B;

• A 类称为子类 或 派生类
• B 类称为父类 或 基类

派生类中的成员，包含两大部分：

• 一类是从基类继承过来的，一类是自己增加的成员。
• 从基类继承过过来的表现其共性，而新增的成员体现了其个性。

# 6.2 继承方式

继承方式：

1. 公共继承
2. 保护继承
3. 私有继承
   

# 6.3 继承中的对象模型

class Base {

public:
        int m_A;
protected:
        int m_B;
private:
        int m_C;
};
class Son : public Base {
public:
        int m_D;
};

void test01() {
        cout << sizeof(Son) << endl;//输出的是16
        return;
}

父类中的所有非静态成员属性都会被子类继承下去
父类中的私有成员属性是被编译器隐藏了，虽然访问不到，但的确被继承了

利用 vs 的开发人员命令提示工具查看对象模型（对象的布局）:

1. 打开工具窗口后，定位到当前 CPP 文件的盘符
2. 然后输入： cl /d1 reportSingleClassLayout 查看的类名 所属文件名
3. 结果如下所示：
   

# 6.4 继承中构造和析构的顺序

继承中：

• 先调用父类构造函数，再调用子类构造函数，
• 析构顺序与构造相反

# 6.5 继承同名成员处理方式

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

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

当子类与父类拥有同名的成员函数（即使参数列表不同），子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数

class Base {
public:
        Base() {
               m_A = 100;
        }
        void func() {
               cout << "父类的函数" << endl;
        }

        void func(int m_A) {
               cout << "父类的函数有参数" << endl;
        }
        int m_A;
};

class Son : public Base {
public:
        Son() {
               m_A = 200;
       }
        void func() {
               cout << "子类的函数" << endl;
        }
        int m_A;

};

void test01() {
        Son b;
        cout << b.m_A << endl;//直接访问，即为子类的同名成员
        cout << b.Base::m_A << endl;//加上作用域，即可访问父类的同名成员
        b.func();//直接访问，即为子类的同名函数
        b.Base::func();//加上作用域，即可访问父类的同名函数

        //当子类与父类拥有同名的成员函数，子类会隐藏父类中所有版本的同名成员函数
        //如果想访问父类中被隐藏的同名成员函数，需要加父类的作用域
        //b.func(100);
        b.Base::func(100);
        return;
}

# 6.6 继承同名静态成员处理方式

静态成员变量复习：

• 类内声明，类外初始化
• 访问方式有两种：1 通过对象访问 2. 通过类名访问

继承同名静态成员处理方式：

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

当子类与父类拥有同名的静态成员函数（即使参数列表不同），子类会隐藏父类中同名静态成员函数，加作用域可以访问到父类中同名静态成员函数

class Base {
public:
        //静态成员变量特点：定义就分配内存，所有对象共享同一份数据
        //类内申明，类外初始化
        static int m_A;
        static void func() {
               cout << "父类的函数" << endl;
        }
};
int Base::m_A = 100;

class Son : public Base {
public:
        static int m_A;
        static void func() {
               cout << "子类的函数" << endl;
        }
};
int Son::m_A = 200;

void test01() {
        //通过对象访问
        cout << "通过对象访问： " << endl;
        Son b;
        cout << "Son下m_A = " << b.m_A << endl;//直接访问，即为子类的同名成员
       cout << "Base下m_A = " << b.Base::m_A << endl;//加上作用域，即可访问父类的同名成员

        //通过类名访问
        cout << "通过类名访问： " << endl;
        cout << "Son下m_A = " << Son::m_A << endl;//直接访问，即为子类的同名成员
        cout << "Base下m_A = " << Base::m_A << endl;//加上作用域，即可访问父类的同名成员
        //第一个::代表通过类名方式访问， 第二个::代表作用域
        cout << "Base下m_A = " << Son::Base::m_A << endl;
        return;
}

void test02() {
       //通过对象访问
        cout << "通过对象访问： " << endl;
        Son s;
        s.func();
        s.Base::func();
        //当子类与父类拥有同名的成员函数，子类会隐藏父类中所有版本的同名成员函数
        //如果想访问父类中被隐藏的同名成员函数，需要加父类的作用域
        //s.func(100);
        s.Base::func(100);
        
        //通过类名访问
        cout << "通过类名访问： " << endl;
        Son::func();
        Base::func();
        Son::Base::func();
        Son::Base::func(100);
}

# 6.7 多继承语法

C++ 允许一个类继承多个类

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

多继承可能会引发父类中有同名成员出现，需要加作用域区分

C++ 实际开发中不建议用多继承

# 6.8 菱形继承

菱形继承概念：两个派生类继承同一个基类，又有某个类同时继承者两个派生类

class Animal
{
public:
	int m_Age;
};

//利用虚继承，可以解决菱形继承的问题
//继承前加virtual关键字后，变为虚继承
//此时公共的父类Animal称为虚基类
class Sheep : virtual public Animal {};
class Tuo   : virtual public Animal {};
class SheepTuo : public Sheep, public Tuo {};

void test01()
{
	SheepTuo st;
	st.Sheep::m_Age = 100;
	st.Tuo::m_Age = 200;

	cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;
	cout << "st.Tuo::m_Age = " <<  st.Tuo::m_Age << endl;
	cout << "st.m_Age = " << st.m_Age << endl;
}

菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费以及毫无意义
利用虚继承可以解决菱形继承问题

# 7. 多态

# 7.1 多态的基本概念

多态分为两类

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

区别：

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

应用：

• 基类中的函数 A 不是虚函数，派生类中的同名函数 Aa，则生成一个派生类对象，只会调用 A
• 基类中的函数 A 是虚函数，派生类中的同名函数 Aa，则生成一个派生类对象，会调用 Aa

多态满足条件

• 有继承关系子类
• 重写父类中的虚函数多态
  重写：函数返回值类型 函数名 参数列表 完全一致称为重写

使用条件

• 父类指针或引用指向子类对象

父类 *指针变量 = new 子类;

多态的优点：

• 代码组织结构清晰
• 可读性强
• 利于前期和后期的扩展以及维护

没有重写时：

发生重写时：

class Animal
{
public:
	//Speak函数就是虚函数
	//函数前面加上virtual关键字，变成虚函数，那么编译器在编译的时候就不能确定函数调用了。
	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}
};

class Cat :public Animal
{
public:
	void speak()
	{
		cout << "小猫在说话" << endl;
	}
};

class Dog :public Animal
{
public:

	void speak()
	{
		cout << "小狗在说话" << endl;
	}

};
//我们希望传入什么对象，那么就调用什么对象的函数
//如果函数地址在编译阶段就能确定，那么静态联编
//如果函数地址在运行阶段才能确定，就是动态联编

void DoSpeak(Animal & animal)
{
	animal.speak();
}
//
//多态满足条件： 
//1、有继承关系
//2、子类重写父类中的虚函数
//多态使用：
//父类指针或引用指向子类对象

void test01()
{
	Cat cat;
	DoSpeak(cat);

	Dog dog;
	DoSpeak(dog);
}

//多态实现
//抽象计算器类
//多态优点：代码组织结构清晰，可读性强，利于前期和后期的扩展以及维护
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;
	}
};

void test02()
{
	//创建加法计算器
	AbstractCalculator *abc = new AddCalculator;
	abc->m_Num1 = 10;
	abc->m_Num2 = 10;
	cout << abc->m_Num1 << " + " << abc->m_Num2 << " = " << abc->getResult() << endl;
	delete abc;  //用完了记得销毁

	//创建减法计算器
	abc = new SubCalculator;
	abc->m_Num1 = 10;
	abc->m_Num2 = 10;
	cout << abc->m_Num1 << " - " << abc->m_Num2 << " = " << abc->getResult() << endl;
	delete abc;  
}

# 7.2 纯虚函数和抽象类

在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容，因此可以将虚函数改为纯虚函数

纯虚函数语法： virtual 返回值类型 函数名 （参数列表）= 0 ;

当类中有了纯虚函数，这个类也称为抽象类

抽象类特点：

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

#include<iostream>
#include<string>
using namespace std;

class AbstractDrinking {
public:
        //煮水，冲泡，倒入杯中，放入佐料
        virtual void Boil() = 0;
        virtual void Brew() = 0;
        virtual void PourIntoCup() = 0;
        virtual void Putsth() = 0;
        void makeDrink() {
               Boil();
               Brew();
              PourIntoCup();
              Putsth();
        }
};

class Coffee :public AbstractDrinking {
public:
        //煮水，冲泡，倒入杯中，放入佐料
        virtual void Boil() {
               cout << "Boil coffee" << endl;
        }
        virtual void Brew() {
               cout << "Brew coffee" << endl;
        }
        virtual void PourIntoCup() {
              cout << "PourIntoCup coffee" << endl;
        }
        virtual void Putsth() {
               cout << "Putsth coffee" << endl;
        }
};

class Tea :public AbstractDrinking {
public:
        //煮水，冲泡，倒入杯中，放入佐料
        virtual void Boil() {
               cout << "Boil Tea" << endl;
        }
        virtual void Brew() {
               cout << "Brew Tea" << endl;
        }
        virtual void PourIntoCup() {
              cout << "PourIntoCup Tea" << endl;
        }
        virtual void Putsth() {
               cout << "Putsth Tea" << endl;
        }
};

void doWork(AbstractDrinking* abs) {
        //父类指针调用接口
        abs->makeDrink();
        delete abs;//释放
}

void test01() {
        doWork(new Coffee);
        doWork(new Tea);
       return;
}

int main() {
        test01();
        system("pause");
        return 0;
}

# 7.3 虚析构和纯虚析构

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

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

虚析构和纯虚析构共性：

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

虚析构和纯虚析构区别：

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

虚析构语法： virtual ~类名(){}
纯虚析构语法： virtual ~类名() = 0;类名::~类名(){}

总结：

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

class Animal
{
public:
        Animal()
        {
               cout << "Animal 构造函数调用！" << endl;
        }
        //Speak函数就是纯虚函数
        virtual void speak() = 0;
         /*~Animal()
        {
               cout << "Animal析构函数调用！" << endl;
        }*/
        //析构函数加上virtual关键字，变成虚析构函数
        /*virtual ~Animal()
        {
               cout << "Animal虚析构函数调用！" << endl;
        }*/
        //纯虚析构,使用的时候，必须要类外实现，因为父类也有可能有数据咋堆区
        //有了纯虚析构之后，类也是抽象类，无法实例化对象
        virtual ~Animal() = 0;
};

//类外实现
Animal::~Animal()
{
        cout << "Animal 纯虚析构函数调用！" << endl;
}

class Cat :public Animal
{
public:
        string *m_Name;
        Cat(string name)
        {
               cout << "Cat构造函数调用！" << endl;
               //堆区创造一个属性
               m_Name = new string(name);
        }
        virtual void speak()
        {
               cout << "小猫在说话" << endl;
        }
        ~Cat()
        {
               cout << "Cat析构函数调用!" << endl;
               if (this->m_Name != NULL) {
                       delete m_Name;
                       m_Name = NULL;
               }
        }
};