目录

<li>类 & 对象
• 封装
  • 访问权限
• 类的构造函数&析构函数
  • 构造函数的分类及调用
    • 拷贝构造函数的调用时机
    • 构造函数调用规则
  • 深拷贝与浅拷贝
  • 初始化列表
  • 类对象作为类成员
  • 静态成员
• C++对象模型和this指针
  • 成员变量和成员函数分开存储
  • this指针概念
  • 空指针访问成员函数
  • const修饰成员函数
• 友元
  • 全局函数做友元
  • 类做友元
  • 成员函数做友元
• 运算符重载
  • 加号运算符重载
  • 左移运算符重载
  • 递增 / 递减运算符重载
  • 赋值运算符重载
  • 关系运算符重载
  • 函数调用运算符重载
• 继承
  • 基本语法
  • 继承方式
  • 构造和析构顺序
  • 继承同名成员处理方式
  • 多继承
  • 菱形继承
• 多态
  • 多态的基本概念
  • 多态案例（一）——计算器类
  • 纯虚函数和抽象类
  • 多态案例（二）——饮品类
  • 虚析构和纯虚析构
  • 多态案例（三）—— 电脑组装

类 & 对象

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

封装

封装的意义：

• 将属性和行为作为一个整体，表现生活中的事物（数据成员和方法）
• 将属性和行为加以权限控制（访问修饰符）

类中的属性和行为我们一般称为成员，属性为成员属性，行为是成员方法

这里以盒子为例，定义一个类，并声明两个对象

<code>class Box

{

//访问权限

//公共权限

public:

//数据成员

double lenth;//长

double breadth; //宽

double height; //高

//方法

//求盒子体积

double cal_Volume()

{

return lenth * breadth * height;

}

};

int main()

{

Box box1;// 声明 box1，类型为 Box

Box box2;// 声明 box2，类型为 Box

//对象box1和box2都有他们各自的成员

}

访问权限

类在设计时，可以把属性和行为放在不同的权限下来加以控制

访问权限有三种：

1. public 公共权限

   其成员类内可以访问，类外可以访问

2. protected 保护权限

   其成员类内可以访问，类外不可以访问，但在子类（派生类）中可以访问

3. private（默认）私有权限

   其成员类内可以访问，类外不可以访问，不可查看

class Person

{

public:

String name;

protected:

int age;

int id_card;//默认为private

public:

func()

{

name = "alen";

age = 26;

id_card = 114514;

}

};

int main()

{

Person p;

p.name = "walker";

p.age = 23;//报错，类外不能访问

p.id_card = 1919810;//报错，类外不能访问

}

struct和class区别

两者的唯一区别在于默认的访问权限：

• struct默认权限为公共

• class默认权限为私有

• class C1

  {

  int a; //默认是私有权限 private

  };

  struct C2

  {

  int a; //默认是公共权限 public

  };

  ---

  成员属性设置为私有

  优点：

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

class Person

{

public:

//设置名字

void setName(string name)

{

m_Name = name;

}

//设置偶像

void setIdol(string idol)

{

m_Idol = idol;

}

//设置年龄

void setAge(int age)

{

if (age < 0 || age > 150)

{

cout<<"年龄"<<age<<"输入有误"<<endl;

return;

}

m_Age = age;

}

string getName()

{

return m_Name;

}

int getAge()

{

return m_Age;

}

private:

string m_Name;//姓名 可读可写

int m_Age = 18;//年龄 只读(当可写的时候，年龄限制在0-150之间)

string m_Idol;//偶像 只写

};

类的构造函数&析构函数

c++中的构造函数和析构函数的作用是对对象的初始化和清理

对象的初始化和清理工作是强制的，如果我们没有提供构造和析构函数的话，编译器将自动提供空实现的构造和析构函数

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

构建函数语法（内联）：类名( ) { }

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

析构函数语法（内联）：~类名( ) { }

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

class Person

{

public:

//构造函数进行初始化操作

Person()

{

cout<<"Person构造函数的调用"<<endl;

}

~Person()

{

cout<<"Person析构函数的调用"<<endl;

}

};

void test01()

{

Person p;//在栈上的数据，p创建时执行构造函数，test01执行完毕后释放这个对象，对象的析构函数被调用

}

int main()

{

test01();

return 0;

}

构造函数的分类及调用

两种分类方式：

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

三种调用方式：

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

class Person

{

public:

//普通构造

Person()

{

cout<<"Person无参函数的调用"<<endl;

}

Person(int a)

{

age = a;

cout<<"Person有参函数的调用"<<endl;

}

//拷贝构造

Person(const Person &p)

{

//将传入对象的所有属性，拷贝到当前对象上

age = p.age;

}

~Person()

{

cout<<"Person析构函数的调用"<<endl;

}

private:

int age;

};

void test01()

{

//括号法

Person p1;//默认构造函数调用

Person p2(10);//有参构造函数

Person p3(p2);//拷贝构造函数

/*

注意事项：

调用默认构造函数的时候，不要加()

因为这句代码“ Person p1(); ”编译器会认为是一个函数声明，不会认为是在创建对象

*/

//显示法

Person p4;

Person p5 = Person(10); //有参

Person p6 = Person(p5); //拷贝

Person(10); //匿名对象 特点：当前行执行结束后，系统会立即回收掉匿名对象

/*

注意事项2：

不要用拷贝构造函数初始化匿名对象

Person(p3) 会被视为对象p3的重定义

*/

//隐式转换法

Person p7 = 10; //有参相当于 Person p7 = Person(10)

Person p8 = p7; //拷贝

}

int main()

{

test01();

return 0;

}

拷贝构造函数的调用时机

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

• 使用一个已经创建完毕的对象来初始化一个新对象
• 值传递的方式给函数参数传值（值传递本质是拷贝一个临时的副本来传递，因此会调用拷贝构造函数）
• 以值方式返回局部对象（同上）

构造函数调用规则

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

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

构造函数调用规则如下：

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

深拷贝与浅拷贝

浅拷贝（默认）：简单的赋值拷贝操作

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

浅拷贝可能带来的问题是堆区的内存重复释放

class Person

{

Person(const Person &p)

{

m_Age = p.m_Age;

m_Height = p.m_Height;//编译器默认的浅拷贝（单纯的值拷贝）

}

Person(const Person &p)

{

m_Age = p.m_Age;

m_Height = new int(*p.m_Height);//深拷贝操作，另外开辟一片堆内存进行拷贝

}

};

初始化列表

作用：c++提供了初始化列表语法，用来初始化属性

语法：构造函数( ) : 属性(值1), 属性(值2)...{ }

class Person

{

//传统初始化操作

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 A

{

};

class B

{

A a;

}

B类中有对象A作为成员，A

静态成员

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

静态成员分为：

• 静态成员变量

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

• 静态成员函数

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

class Person

{

public:

//静态成员变量

//编译阶段就分配内存

static int m_A;

private:

static int m_B;//静态成员变量也有访问权限

};

//类内声明，类外初始化操作

int Person:: m_A = 100;

void test01()

{

Person p;

cout<< p.m_A <<endl;//100

Person p2;

p2.m_A = 200;

cout<< p.m_A <<endl;//200

//所有对象都共享同一份数据

}

void test02()

{

//静态成员变量不专属于某个对象，所有对象都共享同一份数据

//因此静态成员变量有两种访问方式：

//1.通过对象进行访问

Person p;

cout<< p.m_A <<endl;

//2.通过类名进行访问

cout<< Person::m_A<<endl;

}

class Person

{

public:

static void func()

{

cout <<"静态成员函数调用"<< endl;

}

};

void test01()

{

//两种访问方式

//通过对象访问

Person p;

p.func();

//通过类名访问

Person::func();

}

C++对象模型和this指针

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

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

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

class Person

{

};

class Human

{

public:

int m_A;//非静态成员变量属于类的对象上的数据

static int m_B;//静态成员变量不属于类对象上

void func(){}//非静态成员函数不属于类对象上

static void func2(){}//静态成员函数不属于类对象上

};

void test01()

{

Person p;

//空对象占用内存空间为：1 (byte)

//C++编译器会给每个空对象也分配一个字节空间，是为了区分空对象占内存的位置

//每个空对象也应该有一个独一无二的内存地址

cout << "size of p = " << sizeof(p) << endl;

}

void test02()

{

Human p1;

//占4 (byte) -> 非静态成员变量(int)所占的内存

//因为静态成员变量、非静态成员函数、静态成员函数不在类的对象上所以分开存储

cout << "size of p = " << sizeof(p1) << endl;

}

this指针概念

c++中成员变量和成员函数是分开存储的

每一个非静态成员函数只会产生一份函数实例，也就是说多个同类型的对象会公用同一份代码

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

c++通过提供特殊的对象指针，this指针来解决上述问题。this指针指向被调用的成员函数所属的对象

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

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

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

this指针的用途：

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

class Person

{

public:

Person(int age)

{

age = age;//形参和成员属性名字相同，编译器误以为他俩是同一个东西

//this指针指向的是被调用的成员函数（这里调用的是构造函数）所属的对象（这里的对象是p1）

this->age = age;//使用this指针可解决名称冲突

}

//要返回本体的话须加引用

Person& PersonAddAge(Person &p)

{

this->age += p.age;

//this指向p2的指针，而*this指向的就是p2的本身

return *this;

}

int age;//应该使用别的规范名称，如m_Age

};

//1.解决名称冲突

void test01()

{

Person p1(18);

cout << "p1的年龄是" << p1.age << endl;//并非18

}

//2.返回对象本身用*this

void test02()

{

Person p1(10);

Person p2(10);

//返回值为对象本身，即p2 = p2.PersonAddAge(p1)

//链式编程思想

p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1);

cout << "p2的年龄是" << p2.age << endl;//

}

空指针访问成员函数

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

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

//空指针调用成员函数

class Person

{

public:

void showClassName()

{

cout << "this is Person class" << endl;

}

void showPersonAge()

{

//报错的原因是传入的指针为NULL

/*解决措施：

if (this == NULL)

{

return;

}

*/

cout << "age = " << this->m_Age << endl;

}

int m_Age;

};

void test01

{

Person * p = null;

p->showClassName();//不报错

p->showPersonAge();//报错，因为调用了成员属性，但指针为空指针

}

const修饰成员函数

常函数：

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

常对象：

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

//常函数

class Person

{

public:

//在成员函数后面加const，修饰的是this指向，让this指针指向的值也无法修改

void showPerson() const

{

//this->m_A = 100;不可修改

this->m_B = 100;

}

int m_A;

mutable int m_B;//特殊变量，即使在常函数中，也可以修改这个变量

}

void test02()

{

const Person p; //在对象前加const，变为常对象

//p.m_A = 100; 报错

p.m_B = 100; //m_B是特殊值，在常对象中可修改

//常对象只能调用常函数

p.showPerson();

//p.func();//报错常对象不可以调用普通成员函数，因为普通成员函数可以修改属性

}

友元

生活中，家里（class）有客厅（public）也有卧室（private），客厅所有客人都能进，但是卧室除了好友之外的普通客人不能进

在程序里，有些私有属性也想让类外特殊的一些函数或者类进行访问，就需要用到友元的技术

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

友元的关键词为friend

友元的三种实现

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

全局函数做友元

class Building

{

//友元声明

friend void goodFriend(Building &building);

public:

Building()

{

m_SittingRoom = "客厅";

m_BedRoom = "卧室";

}

public:

string m_SittingRoom;

private:

string m_BedRoom;

};

//全局函数

void goodFriend(Building &building)

{

cout << "猴米全局函数正在访问："<< building->m_BedRoom/*private*/ <<endl;

}

void test01()

{

Building building;

goodFriend(&building);//成功访问

}

类做友元

class Building;

class GoodFriend

{

public:

GoodFriend();

void visit(); //参观函数访问Building类中元素

Building * building;

};

class Building

{

//友元声明

friend class GoodFriend;

public:

Building();

public:

string m_SittingRoom;

private:

string m_BedRoom;

};

//类外写成员函数

Building::Building()

{

m_SittingRoom = "客厅";

m_BedRoom = "卧室";

}

GoodFriend::GoodFriend()

{

//创建建筑物对象

building = new Building;

}

void GoodFriend::visit()

{

cout << "猴米类正在访问：" << building->m_BedRoom << endl;

}

void test01()

{

GoodFriend gf;

gf.visit();//调用成功

}

成员函数做友元

class Building;

class GoodFriend

{

public:

GoodFriend();

void visit01(); //让visit01函数可以访问Building类的私有成员

void visit02(); //让visit02函数不可以访问Building类的私有成员

Building * building;

};

class Building

{

//友元声明

friend void GoodFriend::visit01();

public:

Building();

public:

string m_SittingRoom;

private:

string m_BedRoom;

};

//类外写成员函数

Building::Building()

{

m_SittingRoom = "客厅";

m_BedRoom = "卧室";

}

GoodFriend::GoodFriend()

{

//创建建筑物对象

building = new Building;

}

void GoodFriend::visit01()

{

cout << "猴米类正在访问：" << building->m_BedRoom << endl;

}

void GoodFriend::visit01()

{

cout << "猴米类正在访问：" << building->m_BedRoom << endl;//报错

}

运算符重载

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

加号运算符重载

作用：实现两个自定义数据类型相加的运算

Tips：

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

class Person

{

public:

//成员函数重载+号

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;

}

int m_A;

int m_B;

};

//全局函数重载+号

Person operator+(Person &p1, Person &p2)

{

Person temp;

temp.m_A = this->m_A + p.m_A;

temp.m_B = this->m_B + p.m_B;

return temp;

}

void test01

{

Person p1;

p1.m_A = 10;

p1.m_B = 10;

Person P2;

p2.m_A = 10;

p2.m_B = 10;

//成员函数本质调用

//Person p3 = p1.operator+(p2);

Person p3 = p1 + p2;//简化

cout << "p3.m_A = " << p3.m_A << endl;

cout << "p3.m_B = " << p3.m_B << endl;

}

左移运算符重载

作用：可以输出自定义数据类型

class Person

{

friend ostream& operator<<(ostream &cout,Person &p);

public:

Person(int a, int b)

{

m_A = a;

m_B = b;

}

private:

//不会利用成员函数重载<<运算符，因为无法实现cout在左侧

int m_A;

int m_B;

};

//只能利用全局函数重载左移运算符

ostream& operator<<(ostream &cout,Person &p)

{

cout << "m_A = " << p.m_A << " m_B = " << p.m_B;

return cout;

}

void test01()

{

Person p(10,10);

cout << p << endl;

}

int main() {

cout << "Hello, World!" << endl;

test01();

return 0;

}

递增 / 递减运算符重载

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

//重载递增运算符

//自定义整型

class MyInteger

{

friend ostream & operator<<(ostream& cout, MyInteger myint);

public:

MyInteger()

{

m_Num = 0;

}

//重载前置++运算符

//返回引用是为了一直对一个数据进行递增操作

MyInteger& operator++()

{

//先进行++运算

m_Num++;

//再将自身返回

return *this;

}

//重载后置++运算符

//int代表占位参数，可用于区分前置和后置递增

MyInteger operator++(int)

{

//先 记录当时结果

MyInteger temp = *this;

//后 递增

m_Num++;

//最后将记录结果做返回

return temp;

}

//重载前置--运算符

//返回引用是为了一直对一个数据进行递减操作

MyInteger& operator--()

{

//先进行--运算

m_Num--;

//再将自身返回

return *this;

}

//重载后置--运算符

//int代表占位参数，可用于区分前置和后置递减

MyInteger operator--(int)

{

//先 记录当时结果

MyInteger temp = *this;

//后 递减

m_Num--;

//最后将记录结果做返回

return temp;

}

private:

int m_Num;

};

ostream & operator<<(ostream& cout, MyInteger myint)

{

cout << myint.m_Num;

return cout;

}

void test01()

{

MyInteger myint; //0

cout << ++myint << endl;//1

cout << myint++ << endl;//1

cout << myint << endl;//2

cout << --myint << endl;//1

cout << myint-- << endl;//1

cout << myint << endl;//0

}

赋值运算符重载

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

1. 默认构造函数（无参，函数体为空）
2. 默认析构函数（无参，函数体为空）
3. 默认拷贝构造函数，对属性进行值拷贝
4. 赋值运算符operator=，对属性进行值拷贝

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

//赋值运算符重载

class Person

{

public:

Person(int age)

{

m_Age = new int(age);

}

~Person()

{

if (m_Age != NULL)

{

delete m_Age;

m_Age = NULL;

}

}

//重载 赋值运算符

Person& operator=(Person &p)

{

//应该先判断是否有属性在堆区，如有，应先释放干净再进行深拷贝

if (m_Age != NULL)

{

delete m_Age;

m_Age = NULL;

}

//深拷贝

m_Age = new int(*p.m_Age);

//返回对象本身

return *this;

}

int *m_Age;

};

void test01()

{

Person p1(10);

Person p2(20);

Person p3(30);

p3 = p2 = p1; //赋值操作

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

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

cout << "p3's age = " << *p3.m_Age << endl;

}

关系运算符重载

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

//关系运算符重载

class Person

{

public:

Person(string name, int age)

{

m_Name = name;

m_Age = age;

}

//重载==号

bool operator==(Person &p)

{

if (this->m_Name == p.m_Name)

{

return true;

}

return false;

}

//重载!=号

bool operator!=(Person &p)

{

if (this->m_Name != p.m_Name)

{

return true;

}

return false;

}

string m_Name;

int m_Age;

};

void test01()

{

Person p1("Tom",18);

Person p2("Tom",18);

if (p1 == p2)

{

cout << "p1 == p2" << endl;

} else{

cout << "p1 != p2" << endl;

}

}

函数调用运算符重载

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

//函数调用运算符重载

class MyPrint

{

public:

//重载函数调用运算符

void operator()(string test)

{

cout << test <<endl;

}

};

class MyAdd

{

public:

int operator()(int num1, int num2)

{

return num1 + num2;

}

};

void test01()

{

MyPrint myPrint;

myPrint("hello world");

//匿名对象调用

int a = MyAdd()(10,20);

cout << "a = " << a << endl;

}

继承

继承是面向对象三大特性之一

继承允许我们依据另一个类来定义一个类，有重用代码功能和提高执行效率的效果。

当创建一个类时，不必重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可。这个已有的类称为基类，新建的类称为派生类。也可以称为父类与子类

基本语法

class 子类 : 继承方式 父类

class A : public B

以上图为例

<code>// 基类

class Animal {

public:

void eat()

{

cout << "吃！" << endl;

}

void sleep()

{

cout << "zzzZZZ" << endl;

}

string name;

int age;

};

//派生类

class Dog : public Animal {

public:

void bark()

{

cout << "汪汪汪！" << endl;

}

};

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

• 从父类继承过来的
• 自己增加的成员

从父类继承过来的表现其共性，而新增的成员体现了其个性。

一个子类继承了所有的基类方法，但下列情况除外：

• 父类的构造函数、析构函数和拷贝构造函数。
• 父类的重载运算符。
• 父类的友元函数。

继承方式

继承方式一共有三种：

• 公共继承（public）：当一个类派生自公有基类时，基类的公有成员也是派生类的公有成员，基类的保护成员也是派生类的保护成员，基类的私有成员不能直接被派生类访问，但是可以通过调用基类的公有和保护成员来访问。
• 保护继承（protected）：当一个类派生自保护基类时，基类的公有和保护成员将成为派生类的保护成员。
• 私有继承（private）：当一个类派生自私有基类时，基类的公有和保护成员将成为派生类的私有成员。

我们几乎不使用 protected 或 private 继承，通常使用 public 继承。

构造和析构顺序

在继承后，派生类也会继承基类的构造函数与析构函数

那么他们之间的调用顺序如下：

父类构造——子类构造——子类析构——父类析构

继承同名成员处理方式

当子类与父类出现同名的成员时：

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

class Base{

public:

Base()

{

m_A = 100;

}

void func()

{

cout << "Base" << endl;

}

int m_A;

};

class Son:public Base{

public:

Son()

{

m_A = 200;

}

void func()

{

cout << "Son" << endl;

}

int m_A;

};

//同名数据成员处理

void test01()

{

Son s;

cout << "Son下 m_A = " << s.m_A << endl;//200

cout << "Base下 m_A = " << s.Base::m_A << endl;//100

}

//同名成员函数处理

void test02()

{

Son s;

s.func();//Son

s.Base::func();//Base

}

总结：

• 子类对象可以直接访问到子类中同名成员
• 子类对象加作用域可以访问到父类同名函数
• 当子类和父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，但加作用域可以访问到

多继承

多继承即一个子类可以有多个父类，它继承了多个父类的特性。

C++ 类可以从多个类继承成员，语法如下：

class <派生类名>:<继承方式1><基类名1>,<继承方式2><基类名2>,…

{

<派生类类体>

};

c++实际开发中不建议使用多继承，因为可能会引发多个父类中有同名成员导致作用域管理混乱

示例如下：

// 形状基类 Shape

class Shape

{

public:

void setWidth(int w)

{

width = w;

}

void setHeight(int h)

{

height = h;

}

protected:

int width;

int height;

};

// 刷漆基类 PaintCost

class PaintCost

{

public:

int getCost(int area)

{

return area * 70;

}

};

// 派生类

class Rectangle: public Shape, public PaintCost

{

public:

int getArea()

{

return (width * height);

}

};

int main(void)

{

Rectangle Rect;

int area;

Rect.setWidth(5);

Rect.setHeight(7);

area = Rect.getArea();

// 输出对象的面积

cout << "Total area: " << Rect.getArea() << endl;

// 输出总花费

cout << "Total paint cost: $" << Rect.getCost(area) << endl;

return 0;

}

菱形继承

菱形继承概念：

• 两个派生类继承同一个基类
• 又有某个类同时继承着两个派生类
• 这种继承被称为菱形继承，或者钻石继承

典型的菱形继承案例：

菱形继承问题：

<li>老虎继承了动物的数据，狮子同样也继承了动物的数据；当狮虎兽使用数据时，就会产生二义性
• 当菱形继承，两个父类拥有相同数据时，需要加以作用域区分
1. 狮虎兽继承自动物的数据继承了两份，但我们应该清楚，这份数据我们只需要一份即可，导致资源浪费
   • 利用虚继承来解决（在继承方式前加上关键字virtual：class Tiger : virtual public Animal，基类Animal变成虚基类）

多态

多态的基本概念

多态是c++面向对象的三大特性之一

多态按字面的意思就是多种形态。当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。

多态分为两类：

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

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

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

<code>class Animal

{

public:

void speak()

{

cout<<"动物在说话"<<endl;

}

};

class Cat :public Animal

{

public:

void speak()

{

cout<<"meow,meow,meow"<<endl;

}

};

//执行说话的函数

//地址早绑定在编译阶段确定函数地址

//如果想执行让猫说话，那么这个函数地址就不能提前绑定，需要晚绑定

void doSpeak(Animal &animal)

{

animal.speak();

}

void test01()

{

Cat cat;

doSpeak(cat);//动物在说话

}

class Animal

{

public:

//虚函数实现晚绑定

virtual void speak()

{

cout<<"动物在说话"<<endl;

}

};

class Cat :public Animal

{

public:

//重写函数返回值类型、函数名、参数列表完全相同

void speak()

{

cout<<"meow,meow,meow"<<endl;

}

};

//执行说话的函数

void doSpeak(Animal &animal)

{

animal.speak();

}

void test01()

{

Cat cat;

doSpeak(cat);//meow

}

总结：

动态多态满足条件：

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

多态使用条件

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

多态案例（一）——计算器类

案例描述：

分别用普通写法和多态技术，设计实现两个操作数进行的计算器类

多态的优点：

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

//普通实现

class Calculator

{

public:

Calculator(int num1, int num2)

{

m_Num1 = num1;

m_Num2 = num2;

}

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;//操作数1

int m_Num2;//操作数2

};

void test01()

{

//创建一个计算器对象

Calculator c(10,10);

cout << c.m_Num1 << "+" << c.m_Num2 << "=" << c.getResult("+") << endl;

cout << c.m_Num1 << "-" << c.m_Num2 << "=" << c.getResult("-") << endl;

cout << c.m_Num1 << "*" << c.m_Num2 << "=" << c.getResult("*") << endl;

}

//利用多态实现计算器

//实现计算器抽象类

class AbstractCalculator

{

public:

virtual int getResult()

{

return 0;

}

int m_Num1;//操作数1

int m_Num2;//操作数2

};

//加法计算器类

class AddCaculator :public AbstractCalculator

{

public:

virtual int getResult()

{

return m_Num1 + m_Num2;

}

};

//减法计算器类

class SubCaculator :public AbstractCalculator

{

public:

virtual int getResult()

{

return m_Num1 - m_Num2;

}

};

//乘法计算器类

class MulCaculator :public AbstractCalculator

{

public:

virtual int getResult()

{

return m_Num1 * m_Num2;

}

};

void test02()

{

//多态使用条件：父类指针/引用指向子类对象

//加法运算

AbstractCalculator * abc = new AddCaculator;//父类指针

abc->m_Num1 = 100;

abc->m_Num2 = 100;

cout << abc->m_Num1 << "+" << abc->m_Num2 << "=" << abc->getResult() << endl;

//用完后记得销毁

delete abc;

//减法运算

abc = new SubCaculator;

abc->m_Num1 = 100;

abc->m_Num2 = 100;

cout << abc->m_Num1 << "-" << abc->m_Num2 << "=" << abc->getResult() << endl;

//用完后记得销毁

delete abc;

//乘法运算

abc = new MulCaculator;

abc->m_Num1 = 100;

abc->m_Num2 = 100;

cout << abc->m_Num1 << "*" << abc->m_Num2 << "=" << abc->getResult() << endl;

//用完后记得销毁

delete abc;

}

纯虚函数和抽象类

在多态中，通常父类中虚函数的实现是无意义的，主要是调用子类重写的内容（例如计算器类案例中的抽象计算器类）

因此可以将虚函数改为纯虚函数

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

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

抽象类特点：

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

class AbstractCalculator//有纯虚函数的类就是抽象类

{

public:

//纯虚函数

virtual int getResult() = 0;

int m_Num1;//操作数1

int m_Num2;//操作数2

};

//加法计算器类

class AddCalculator : public AbstractCalculator

{

public:

virtual int getResult()

{

return m_Num1 + m_Num2;

}

};

void test01()

{

//多态使用条件：父类指针/引用指向子类对象

//加法运算

AbstractCalculator * abc = new AddCalculator;//父类指针

abc->m_Num1 = 100;

abc->m_Num2 = 100;

cout << abc->m_Num1 << "+" << abc->m_Num2 << "=" << abc->getResult() << endl;

//用完后记得销毁

delete abc;

AbstractCalculator abc;//报错抽象类无法实例化对象

new AbstractCalculator;//报错 堆区或栈区都不行

}

多态案例（二）——饮品类

案例描述：

制作饮品的大致流程为：煮水 - 冲泡 - 倒入杯中 - 加入辅料

利用多态技术实现本案例，提供抽象制作饮品基类，提供子类制作咖啡和茶叶

class AbstractDrinking

{

public:

//煮水

virtual void Boil() = 0;

//冲泡

virtual void Brew() = 0;

//倒入杯中

virtual void PourInCup() = 0;

//加入辅料

virtual void PutSth() = 0;

//制作饮品

void makeDrink()

{

Boil();

Brew();

PourInCup();

PutSth();

}

};

//制作咖啡

class Coffee :public AbstractDrinking

{

//煮水

virtual void Boil(){

cout << "用阿拉斯加山脉泉水煮水" << endl;

}

//冲泡

virtual void Brew(){

cout << "冲泡咖啡" << endl;

}

//倒入杯中

virtual void PourInCup(){

cout << "倒入咖啡杯中" << endl;

}

//加入辅料

virtual void PutSth(){

cout << "加入方糖和牛奶" << endl;

}

};

//制作茶叶

class Tea :public AbstractDrinking

{

//煮水

virtual void Boil(){

cout << "用长白山泉水煮水" << endl;

}

//冲泡

virtual void Brew(){

cout << "冲泡茶叶" << endl;

}

//倒入杯中

virtual void PourInCup(){

cout << "倒入茶杯中" << endl;

}

//加入辅料

virtual void PutSth(){

cout << "加入茉莉花" << endl;

}

};

//制作函数

void doWork(AbstractDrinking * abs)

{

abs->makeDrink();

delete abs; //释放堆区数据

}

void test01()

{

//制作咖啡

doWork(new Coffee);

cout << "----------------" << endl;

//制作茶叶

doWork(new Tea);

}

虚析构和纯虚析构

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

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

虚析构或者纯虚析构共性：

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

虚析构或者纯虚析构区别：

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

虚析构语法：

virtual ~类名( ) { }

纯虚析构语法：

virtual ~类名( ) = 0 ;

类名：：~类名（）{ }

总结：

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

多态案例（三）—— 电脑组装

案例描述：

电脑主要组成部分为CPU（计算）、显卡（显示）和内存条（存储）

将每个零件封装成抽象基类，并且提供不同的厂商生产的不同的零件，例如Intel和AMD厂商

创建电脑类提供让电脑工作的函数，并且调用每个零件工作的接口

测试时组装三台不同的电脑进行工作

//抽象类

//CPU

class CPU

{

public:

//抽象计算函数

virtual void Calculate() = 0;

};

//GPU

class GPU

{

public:

//抽象显示函数

virtual void Display() = 0;

};

//内存条

class Memory

{

public:

//抽象存储函数

virtual void Storage() = 0;

};

//电脑类

class Computer

{

public:

Computer(CPU * cpu, GPU * gpu, Memory * mem)

{

m_cpu = cpu;

m_gpu = gpu;

m_mem = mem;

}

//提供工作的函数

void work()

{

//调用零件接口

m_cpu->Calculate();

m_gpu->Display();

m_mem->Storage();

}

//提供析构函数来释放3个创建在堆区的电脑零件

~Computer()

{

if (m_cpu != NULL)

{

delete m_cpu;

m_cpu = NULL;

}

if (m_gpu != NULL)

{

delete m_gpu;

m_gpu = NULL;

}

if (m_mem != NULL)

{

delete m_mem;

m_mem = NULL;

}

}

private:

CPU * m_cpu;//CPU的零件指针

GPU * m_gpu;//GPU的零件指针

Memory * m_mem;//内存条的零件指针

};

//具体厂商零件

//Intel

class IntelCPU :public CPU

{

public:

virtual void Calculate()

{

cout << "Intel CPU is working!" << endl;

}

};

class IntelGPU :public GPU

{

public:

virtual void Display()

{

cout << "Intel GPU is working!" << endl;

}

};

class IntelMemory :public Memory

{

public:

virtual void Storage()

{

cout << "Intel Memory is working!" << endl;

}

};

//AMD

class AMDCPU :public CPU

{

public:

virtual void Calculate()

{

cout << "AMD CPU is working!" << endl;

}

};

class AMDGPU :public GPU

{

public:

virtual void Display()

{

cout << "AMD GPU is working!" << endl;

}

};

class AMDMemory :public Memory

{

public:

virtual void Storage()

{

cout << "AMD Memory is working!" << endl;

}

};

void test01()

{

//no.1 pc

CPU * intelCpu = new IntelCPU;

GPU * intelGpu = new IntelGPU;

Memory * intelMem = new IntelMemory;

Computer * pc1 = new Computer(intelCpu,intelGpu,intelMem);

pc1->work();

delete pc1;

//no.2 pc

CPU * amdCpu = new AMDCPU;

GPU * amdGpu = new AMDGPU;

Memory * amdMem = new AMDMemory;

Computer * pc2 = new Computer(amdCpu,amdGpu,amdMem);

pc1->work();

delete pc2;

}