文章目录
一、继承
1. 基本语法
继承的好处:可以减少重复的代码
class 子类 : 继承方式 父类
A类称为子类 或 派生类
B类称为父类 或 基类
派生类中的成员,包含两大部分:
一类是从基类继承过来的,一类是自己增加的成员
从基类继承过来的表现其共性,而新增的成员体现其个性
代码如下(示例):
#include<iostream>
using namespace std;
//公共页面类
class common
{
public:
void header()
{
cout << "hello world" << endl;
}
void ender()
{
cout << "goodbye" << endl;
}
};
//java页面
class java : public common
{
public:
void contnent()
{
cout << "java学科视频" << endl;
}
};
//c++页面
class cpp : public common
{
public:
void contnent()
{
cout << "C++学科视频" << endl;
}
};
void test01()
{
java jp;
jp.header();
jp.contnent();
jp.ender();
cpp c;
c.header();
c.contnent();
c.ender();
}
int main()
{
test01();
return 0;
}
2. 继承方式
继承的语法:class 子类 : 继承方式 父类
继承方式一共有三种:
- 公共继承
- 保护继承
- 私有继承
总结:父类的私有权限内容继承不到。
保护继承:将父类中的公共权限变为了保护权限
私有继承:将父类中的公共权限和保护权限内容变为了私有权限
3. 继承中的对象模型
问题:从父类继承过来的成员,哪些属于子类对象中
代码如下(示例):
#include<iostream>
using namespace std;
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 :" << sizeof(son) << endl; //16
}
//利用开发人员命令提示工具查看对象模型
//跳转盘符
//跳转文件路径 cd 具体路径下
//cl /d1 reportSingleClassLayout类名 文件名
int main()
{
test01();
return 0;
}
结论:父类中的私有成员也是被子类继承下去了,只是被编译器给隐藏后访问不到
4. 继承中构造和析构顺序
子类继承父类后,当创建子类对象,也会调用父类的构造函数
问题:父类和子类的构造和析构顺序是谁先谁后?
父类构造函数先调用,
子类析构函数先调用
代码如下(示例):
class base
{
public:
base()
{
cout << "base的构造函数调用" << endl;
}
~base()
{
cout << "base的析构函数调用" << endl;
}
};
//公共继承
class son :public base
{
public:
son()
{
cout << "son的构造函数调用" << endl;
}
~son()
{
cout << "son的析构函数调用" << endl;
}
};
void test01()
{
son p1;
}
5. 继承同名成员处理方式
问题:当子类与父类出现同名的成员,如何通过子类对象,访问到子类或父类中同名的数据呢?
- 访问子类同名成员 直接访问即可
- 访问父类同名成员 需要加作用域
代码如下(示例):
#include<iostream>
using namespace std;
//继承中同名成员处理
class base
{
public:
base()
{
m_a = 100;
}
void func()
{
cout << "base-func的调用" << endl;
}
void func(int a)
{
cout << "base1-func的调用" << endl;
}
int m_a;
};
class son : public base
{
public:
son()
{
m_a = 200;
}
void func()
{
cout << "son-func的调用" << endl;
}
int m_a;
};
//同名成员属性处理
void test01()
{
son s;
cout << "子类的m_a = " << s.m_a << endl;
//如果通过子类对象,访问到父类中同名成员,需要加作用域
cout << "父类的m_a = " << s.base::m_a << endl;
}
//同名成员函数处理
void test02()
{
son s1;
s1.func();
s1.base::func();
//如果子类中出现和父类同名的成员函数,子类的同名成员会隐藏掉父类中所有同名成员函数
//如果想访问到父类中被隐藏的同名成员函数,需要加作用域
s1.base::func(10);
}
int main()
{
//test01();
test02();
return 0;
}
总结:
1.子类对象可以直接访问到子类中同名成员
2.子类对象加作用域可以访问到父类同名成员
3.当子类与父类拥有同名的成员函数,子类会隐藏父类中同名成员函数,加作用域可以访问到父类中同名函数
6. 继承同名静态成员处理方法
问题:继承中同名的静态成员在子类对象上如何进行访问?
静态成员和非静态成员出现同名,处理方式一致
- 访问子类同名成员 直接访问即可
- 访问父类同名成员 需要加作用域
代码如下(示例):
#include<iostream>
using namespace std;
//继承中同名成员处理
class base
{
public:
static int m_a;
static void func()
{
cout << "base-static void func()" << endl;
}
};
int base::m_a = 100;
class son : public base
{
public:
static void func()
{
cout << "son-static void func()" << endl;
}
static int m_a;
};
int son::m_a = 200;
//静态同名成员属性处理
void test01()
{
//1.通过对象访问
cout << "通过对象访问" << endl;
son s;
cout << "son下 m_a = " << s.m_a << endl;
cout << "base下 m_a = " << s.base::m_a << endl;
//2.通过类名访问
cout << "通过类名访问" << endl;
cout << "son下 m_a = " << son::m_a << endl;
//第一个::代表通过类名方式访问 第二个::代表访问父类作用域下
cout << "base下 m_a = " << son::base::m_a << endl;
}
//静态同名成员函数处理
void test02()
{
//1.通过对象访问
son s;
s.func();
s.base::func();
//2.通过类名访问
son::func();
son::base::func();
}
int main()
{
test01();
test02();
return 0;
}
总结:同名静态成员处理方式和非静态处理方式一样,只不过静态成员有两种访问的方式(通过对象 和 通过类名)
7. 多继承语法
C++允许一个类继承多个类
语法:class 子类 :继承方式 父类1 , 继承方式 父类2...
多继承可能会引发父类中有同名成员出现,需要加作用域区分
8. 菱形继承
菱形继承概念:
两个派生类继承同一个基类
又有某个类同时继承这两个派生类
这种继承被称为菱形继承,或者钻石继承
代码如下(示例):
#include<iostream>
using namespace std;
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 = 200;
st.tuo::m_age = 100;
//保留的数据是最后那个
cout << "st.sheep::m_age = " << st.sheep::m_age << endl; //100
cout << "st.tuo::m_age = " << st.tuo::m_age << endl; //100
cout << "st.m_age = " << st.m_age << endl; //100
}
int main()
{
test01();
return 0;
}
总结:
- 菱形继承带来的主要问题是子类继承两份相同的数据,产生二义性,导致资源浪费以及毫无意义
- 利用虚继承可以解决菱形继承问题
二、多态
1. 多态的基本语法
多态分为两类
- 静态多态:函数重载 和 运算符重载属于静态多态 ,复用函数名
- 动态多态:派生类和虚函数实现运行时多态
静态多态和动态多态区别:
- 静态多态的函数地址早绑定 - 编译阶段确定函数地址
- 动态多态的函数地址晚绑定 - 运行阶段确定函数地址
代码如下(示例):
#include<iostream>
using namespace std;
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);
}
int main()
{
test01();
return 0;
}
总结:
多态满足条件
- 有继承关系
- 子类重写父类中的虚函数
多态使用条件
- 父类指针或引用指向子类对象
重写:函数返回值类型 函数名 参数列表 完全一致称为重写
2. 多态案例一 计算器类
案例描述:
分别利用普通写法和多态技术,设计实现两个操作数进行运算的计算器
多态的优点:
- 代码组织结构清晰
- 可读性强
- 利于前期和后期的扩展以及维护
代码如下(示例):
#include<iostream>
using namespace std;
//实现计算器抽象类
class abstractcaculator
{
public:
virtual int getresult()
{
return 0;
}
int m_num1;
int m_num2;
};
//加法计算器
class addcaculator :public abstractcaculator
{
public:
int getresult()
{
return m_num1 + m_num2;
}
};
//减法计算器
class subcaculator :public abstractcaculator
{
public:
int getresult()
{
return m_num1 - m_num2;
}
};
//乘法计算器
class mulcaculator :public abstractcaculator
{
public:
int getresult()
{
return m_num1 * m_num2;
}
};
void test01()
{
//创建加法计算器
abstractcaculator* abc = new addcaculator; //用父类指针或引用 指向子类
abc->m_num1 = 10;
abc->m_num2 = 20;
cout << abc->getresult() << endl;
delete abc; //用完了记得销毁
//创建减法计算器
abc = new subcaculator;
abc->m_num1 = 10;
abc->m_num2 = 10;
cout << abc->getresult() << endl;
delete abc;
//创建乘法计算器
abc = new mulcaculator;
abc->m_num1 = 10;
abc->m_num2 = 10;
cout << abc->getresult() << endl;
delete abc;
}
int main()
{
test01();
return 0;
}
3. 纯虚函数和抽象类
在多态中,通常父类中虚函数的实现是毫无意义的,主要都是调用子类重写的内容
因此可以将虚函数改为纯虚函数
纯虚函数语法:virtual 返回值类型 函数名 (参数列表)= 0
当类中有了纯虚函数,这个类也称为抽象类
抽象类特点:
- 无法实例化对象
- 子类必须重写抽象类中的纯虚函数,否则也属于抽象类
代码如下(示例):
class base
{
public:
//纯虚函数
//只要有一个纯虚函数,这个类称为抽象类
//抽象类特点:
//1.无法实例化对象
//2.抽象类的子类,必须要重写父类中的纯虚函数,否则也属于抽象类
virtual void func() = 0;
};
class son : public base
{
public:
virtual void func()
{
cout << "func调用" << endl;
}
};
void test01()
{
base* base = NULL;
//base = new base; 错误,抽象类无法实例化对象
base = new son;
base->func();
delete base; //记得销毁
}
4. 多态案例二—制作饮品
利用多态技术实现本案例,提供抽象制作饮品类,提供子类制作咖啡和茶叶
代码如下(示例):
//制作饮品
class abstractdrinking
{
public:
//煮水
virtual void boil() = 0;
//冲泡
virtual void brew() = 0;
//倒入杯中
virtual void pourincup() = 0;
//加入辅料
virtual void putsomething() = 0;
//制作饮品
void makedrink()
{
boil();
brew();
pourincup();
putsomething();
}
};
//制作咖啡
class coffee :public abstractdrinking
{
public:
//煮水
virtual void boil()
{
cout << "煮农夫山泉" << endl;
};
//冲泡
virtual void brew()
{
cout << "冲泡咖啡" << endl;
};
//倒入杯中
virtual void pourincup()
{
cout << "倒入杯中" << endl;
};
//加入辅料
virtual void putsomething()
{
cout << "加入糖和牛奶" << endl;
};
};
//制作茶叶
class tea :public abstractdrinking
{
public:
//煮水
virtual void boil()
{
cout << "煮开水" << endl;
};
//冲泡
virtual void brew()
{
cout << "冲泡茶叶" << endl;
};
//倒入杯中
virtual void pourincup()
{
cout << "倒入杯中" << endl;
};
//加入辅料
virtual void putsomething()
{
cout << "加入柠檬" << endl;
};
};
//制作的函数
void dowork(abstractdrinking *abs) //用父类的指针或引用指向子类的对象
{
abs->makedrink();
delete abs; //释放
}
void test01()
{
//制作咖啡
dowork(new coffee);
cout << "-------------" << endl;
//制作茶叶
dowork(new tea);
}
5. 虚析构和纯虚析构
多态使用时,如果子类中有属性开辟到堆区,那么父类指针在释放时无法调用到子类的析构代码
解决方式:将父类中的析构函数改为虚析构或纯虚析构
虚析构和纯虚析构共性:
- 可以解决父类指针释放子类对象
- 都需要有具体的函数实现
虚析构和纯虚析构的区别:
- 如果是纯虚析构,该类属于抽象类,无法实例化对象
虚析构语法:virtual ~类名(){}
纯虚析构语法:
virtual ~类名() = 0
类名::~类名(){}
代码如下(示例):
class animal
{
public:
animal()
{
cout << "animal的构造函数调用" << endl;
}
//利用虚析构可以解决 父类指针释放子类对象时不干净的问题
/*virtual ~animal()
{
cout << "animal的析构函数调用" << endl;
}*/
//纯虚析构 有了纯虚析构之后,这个类也属于抽象类,无法实例化对象
virtual ~animal() = 0;
//纯虚函数
virtual void speak() = 0;
};
animal::~animal()
{
cout << "animal的析构函数调用" << endl;
}
class cat :public animal
{
public:
cat(string name)
{
cout << "cat的构造函数" << endl;
m_name = new string(name);
}
virtual void speak()
{
cout << *m_name<<"小猫在说话" << endl;
}
~cat()
{
if (m_name != NULL)
{
cout << "调用cat的析构函数" << endl;
delete m_name;
m_name = NULL;
}
}
string *m_name;
};
void test01()
{
animal* animal = new cat("tom");
animal->speak();
//父类指针在析构时候 不会调用子类中析构函数,导致子类如果有堆区属性,会出现内存泄漏
delete animal;
}
总结:
1. 虚析构或纯虚析构就是用来解决通过父类指针释放子类对象
2. 如果子类中没有堆区数据,可以不写虚析构或纯虚析构
3. 拥有纯虚析构函数的类也属于抽象类
6. 多态案例三–电脑组装
案例描述:
电脑主要组成部件为:CPU(用于计算),显卡(用于显示),内存条(用于存储)
将每个零件封装出抽象基类,并且提供不同的厂商生产不同的零件,例如intel厂商和lenovo厂商
创建电脑类提供让电脑工作的函数,并且调用每个零件工作的接口
测试时组装三台不同的电脑进行工作
代码如下(示例):
#include<iostream>
using namespace std;
#include<string>
//抽象不同零件类
//抽象CPU类
class cpu
{
public:
//抽象的计算函数
virtual void calculate() = 0;
};
//抽象显卡类
class videocard
{
public:
//抽象的显示函数
virtual void display() = 0;
};
//抽象内存条类
class memory
{
public:
//抽象的存储函数
virtual void storage() = 0;
};
//电脑类
class computer
{
public:
computer(cpu* cpu, videocard* vc, memory* mem)
{
m_cpu = cpu;
m_vc = vc;
m_mem = mem;
}
//提供工作函数
void work()
{
m_cpu->calculate();
m_mem->storage();
m_vc->display();
}
virtual ~computer()
{
//释放cpu零件
if (m_cpu != NULL)
{
delete m_cpu;
m_cpu = NULL;
}
//释放显卡零件
if (m_vc != NULL)
{
delete m_vc;
m_vc = NULL;
}
//释放内存条零件
if (m_mem != NULL)
{
delete m_mem;
m_mem= NULL;
}
}
private:
cpu* m_cpu; //cpu的零件指针
videocard* m_vc; //显卡的零件指针
memory* m_mem; //内存条的零件指针
};
//具体厂商
//intel厂商
class intelcpu :public cpu
{
public:
virtual void calculate()
{
cout << "intel的cpu开始计算" << endl;
}
};
class intelvideocard :public videocard
{
public:
virtual void display()
{
cout << "intel的显卡开始显示" << endl;
}
};
class intelmemory :public memory
{
public:
virtual void storage()
{
cout << "intel的内存条开始存储" << endl;
}
};
//lenovo厂商
class lenovocpu :public cpu
{
public:
virtual void calculate()
{
cout << "lenovo的cpu开始计算" << endl;
}
};
class lenovovideocard :public videocard
{
public:
virtual void display()
{
cout << "lenovo的显卡开始显示" << endl;
}
};
class lenovomemory :public memory
{
public:
virtual void storage()
{
cout << "lenovo的内存条开始存储" << endl;
}
};
void test01()
{
//第一台电脑的零件
cpu* n_intelcpu = new intelcpu;
videocard* n_intelvideocard = new intelvideocard;
memory* n_intelmemory = new intelmemory;
//创建第一台电脑
computer* n_computer = new computer(n_intelcpu, n_intelvideocard, n_intelmemory);
n_computer->work();
delete n_computer;
cout << "第二台电脑开始工作" << endl;
//第二台电脑组装
cpu* n_lenovocpu = new lenovocpu;
videocard* n_lenovovideocard = new lenovovideocard;
memory* n_lenovomemory = new lenovomemory;
//创建第二台电脑
computer* n_computer1 = new computer(n_lenovocpu, n_lenovovideocard, n_lenovomemory);
n_computer1->work();
delete n_computer1;
}
int main()
{
test01();
return 0;
}
7. 父类要析构子类的对象要用虚析构
- 构造时,先构造父类,再构造子类部分,因此父类和子类的构造函数都会被调用;
- 析构时,要分情况
(1)(父类析构函数不是虚函数)使用父类指针指向子类对象,析构该子类对象时,只会调用父类析构函数,因为不具多态性;代码理解
class child:public parent{};
parent *p = new child();
delete p; //调用父类析构函数,子类析构函数不会被调用
(2) 如果子类对象存在资源在堆区,子类的析构函数没被调用,资源就释放不掉。可以使用虚函数。然后会先调用子类析构函数,然后再调用父类析构函数
class parent{
virtual ~parent();
};
class child:public parent
{
~child();
};
parent *p = new child();
delete p; //先调用子类的析构函数,再调用父类的析构函数
(3)对于第一种非虚函数的情况,如果是用子类指针指向子类对象,那么会先调用子类析构函数,再调用父类析构函数,子类释放子类中分配的,父类分配父类中分配的。
class child:public parent{};
child*p = new child();
delete p; //先调用子类的析构函数,再调用父类的析构函数
既然第三种方法也能够让父类和子类的资源都释放掉,为什么还需要使用virtual呢?这是为了让面向对象具有多态性,更简单的理解是方便编程,使用父类指针具有通用性,特别是大型系统开发中。