c++学习笔记(四):面向对象
类 & 对象
c++面向对象的三大特征为:封装、继承、多态
封装
封装的意义:
- 将属性和行为作为一个整体,表现生活中的事物(数据成员和方法)
- 将属性和行为加以权限控制(访问修饰符)
类中的属性和行为我们一般称为成员,属性为成员属性,行为是成员方法
这里以盒子为例,定义一个类,并声明两个对象
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都有他们各自的成员 }
访问权限
类在设计时,可以把属性和行为放在不同的权限下来加以控制
访问权限有三种:
-
public 公共权限
其成员类内可以访问,类外可以访问
-
protected 保护权限
其成员类内可以访问,类外不可以访问,但在子类(派生类)中可以访问
-
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 };
成员属性设置为私有
优点:
- 将所有成员属性设置为私有,可以自己控制读写权限
- 对于写权限,我们可以检测数据的有效性
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++中的构造函数和析构函数的作用是对对象的初始化和清理
对象的初始化和清理工作是强制的,如果我们没有提供构造和析构函数的话,编译器将自动提供空实现的构造和析构函数
- 构造函数:主要作用在于创建对象时为对象的成员属性赋值,构造函数由编译器自动调用,无需手动调用
- 析构函数:主要作用在于对象销毁前系统自动调用,执行一些清理工作
构建函数语法(内联):类名( ) { }
- 没有返回值,也不用写void
- 函数名称与类名相同
- 构造函数可以有参数,因此可以发生重载
- 程序在调用对象的时候会自动调用构造,无须手动调用,而且只会调用一次
析构函数语法(内联):~类名( ) { }
- 没有返回值,也不用写void
- 函数名称与类名相同,在名称前加上符号 ~
- 析构函数不可以有参数,因此不可以发生重载
- 程序在对象销毁前会自动调用析构,无须手动调用,而且只会调用一次
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个函数
- 默认构造函数(无参,函数体为空)
- 默认析构函数(无参,函数体为空)
- 默认拷贝函数,对属性进行值拷贝
构造函数调用规则如下:
- 如果用户定义有参构造函数,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个函数
- 默认构造函数(无参,函数体为空)
- 默认析构函数(无参,函数体为空)
- 默认拷贝构造函数,对属性进行值拷贝
- 赋值运算符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
以上图为例
// 基类 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; }
菱形继承
菱形继承概念:
- 两个派生类继承同一个基类
- 又有某个类同时继承着两个派生类
- 这种继承被称为菱形继承,或者钻石继承
典型的菱形继承案例:
菱形继承问题:
- 老虎继承了动物的数据,狮子同样也继承了动物的数据;当狮虎兽使用数据时,就会产生二义性
- 当菱形继承,两个父类拥有相同数据时,需要加以作用域区分
- 狮虎兽继承自动物的数据继承了两份,但我们应该清楚,这份数据我们只需要一份即可,导致资源浪费
- 利用虚继承来解决(在继承方式前加上关键字virtual:class Tiger : virtual public Animal,基类Animal变成虚基类)
多态
多态的基本概念
多态是c++面向对象的三大特性之一
多态按字面的意思就是多种形态。当类之间存在层次结构,并且类之间是通过继承关联时,就会用到多态。调用成员函数时,会根据调用函数的对象的类型来执行不同的函数。
多态分为两类:
- 静态多态:函数重载和运算符重载属于静态多态,服用函数名
- 动态多态:派生类和虚函数来实现运行时的多态
静态多态和动态多态区别:
- 静态多态的函数地址早绑定 —— 编译阶段确定函数地址
- 动态多态的函数地址晚绑定 —— 运行阶段确定函数地址
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 }
总结:
动态多态满足条件:
- 有继承关系
- 子类重写父类的虚函数
多态使用条件
- 父类指针或引用指向子类对象
多态案例(一)——计算器类
案例描述:
分别用普通写法和多态技术,设计实现两个操作数进行的计算器类
多态的优点:
- 代码组织结构清晰
- 可读性强
- 利于前期和后期的扩展以及维护
//普通实现 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 ;
类名::~类名(){ }
总结:
- 虚析构或纯虚析构就是用来解决父类指针释放子类对象
- 如果子类中没有堆区数据,可以不写为虚析构或纯虚析构
- 拥有纯虚析构函数的类也属于抽象类
多态案例(三)—— 电脑组装
案例描述:
电脑主要组成部分为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; }
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】凌霞软件回馈社区,博客园 & 1Panel & Halo 联合会员上线
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】博客园社区专享云产品让利特惠,阿里云新客6.5折上折
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步