C++[多态]

惊雷无声 · 2024-12-7 12:50:47

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要登录才可以下载或查看，没有账号？立即注册

x

2023-3-14首次编辑

复制代码

Unit 8:多态

一.概念

同一个操作作用域不同的对象,可以有不同的解释,会产生不同的效果

#define _CRT_SECIRE_NO_WARNINGS
#include <iostream>
using namespace std;
class People
{
public:
virtual void Mypro()
{
//虚函数
}
};
class xishi :public People
{
public:
//重写父类的虚函数
virtual void Mypro()
{
cout << "约西施" << endl;
}
};
class wangzhaojun :public People
{
public:
//重写父类的虚函数
virtual void Mypro()
{
cout << "约王昭君" << endl;
}
};
class diaochan :public People
{
public:
//重写父类的虚函数
virtual void Mypro()
{
cout << "约貂蝉" << endl;
}
};
class yangguifei :public People
{
public:
//重写父类的虚函数
virtual void Mypro()
{
cout << "约杨贵妃" << endl;
}
};
//2.同一个操作
void doLogin(People* pro)
{
pro->Mypro(); //3.产生不同的效果
}
void test()
{
People* pro = NULL;
pro = new xishi;
doLogin(pro); //1.不同对象
delete pro;
pro = new wangzhaojun;
doLogin(pro); //1.不同对象
delete pro;
pro = new diaochan;
doLogin(pro); //1.不同对象
delete pro;
pro = new yangguifei;
doLogin(pro); //1.不同对象
delete pro;
}
int main()
{
test();
system("pause");
return 0;
}

复制代码

作用:

可以解决项目中的紧耦合问题,提供步伐的可扩展性
应用步伐不必为每一个子类的功能调用编写代码,只需要对抽象的父类进行处理

多态发生的条件:

有继续
重写父类的虚函数
父类指针指向子类对象

二.多态的实现原理

#define _CRT_SECIRE_NO_WARNINGS
#include <iostream>
using namespace std;
class Animal
{
public:
virtual void speak()
{
cout << "Animal speak()" << endl;
}
};
class Dog :public Animal
{
public:
virtual void speak()
{
cout << "Dog speak()" << endl;
}
};
void test()
{
cout << sizeof(Animal) << endl;
Animal* animal = new Dog;
animal->speak();
}
int main()
{
test();
system("pause");
return 0;
}

复制代码

三.纯虚函数和抽象类

#define _CRT_SECIRE_NO_WARNINGS
#include <iostream>
using namespace std;
//1.依赖倒转:
// 业务层依赖抽象层,实现层依赖抽象层
//抽象层
class rule1
{
public:
virtual int getnum(int a, int b)
{
return 0;
}
};
//实现层
class plus_rule :public rule1
{
//重写父类的虚函数,依赖抽象层
virtual int getnum(int a, int b)
{
return a + b;
}
};
//业务层
int doLogin(rule1* cal)
{
int a = 10;
int b = 20;
int ret = cal->getnum(a, b); //依赖抽象层
return ret;
}
//2.开闭原则:
// 对修改源代码关闭,对扩展新功能开发
class miux_rule :public rule1
{
public:
//扩展新功能
virtual int getnum(int a, int b)
{
return a - b;
}
};
void test1()
{
rule1* r = NULL;
r = new plus_rule;
cout << doLogin(r) << endl;
delete r;
r = new miux_rule;
cout << doLogin(r) << endl;
delete r;
}
//3.纯虚函数:
class rule2
{
public:
virtual int getnum(int a, int b) = 0;
};
//4.抽象类:
// A.有纯虚函数的类叫抽象类,不能实例化对象
// B.如果子类继承抽象类,子类必须实现抽象类的所有纯虚函数,不然子类也变为抽象类
class Maker
{
public:
virtual void func1() = 0;
virtual void func2() = 0;
};
class Son :public Maker
{
public:
virtual void func1()
{
}
virtual void func2()
{
}
};
void test2()
{
//Maker a; //err
Son s;
}
int main()
{
test1();
test2();
system("pause");
return 0;
}

复制代码

四.接口的定义

将内部实现细节封装起来
外部用户通过预留的接口可以利用接口的功能
而不需要知道内部具体细节

C++中,通过类实现面向对象的编程
而在基类中只给出虚函数的声明
然后在派生类中通过实现纯虚函数的具体定义的方式,实现接口
不同的派生类实现接口的方式也不尽相同

#define _CRT_SECIRE_NO_WARNINGS
#include <iostream>
using namespace std;
//抽象类
class Father
{
public:
//接口的声明
virtual void func1() = 0;
virtual void func2(int a) = 0;
virtual void func3(int a, int b) = 0;
};
class Son :public Father
{
public:
//接口的实现
virtual void func1()
{
}
virtual void func2(int a)
{
}
virtual void func3(int a, int b)
{
}
};
int main()
{
system("pause");
return 0;
}

复制代码

五.模板方法模式

在类中确定好函数的调用顺序

#define _CRT_SECIRE_NO_WARNINGS
#include <iostream>
using namespace std;
class Drink
{
public:
//烧水
virtual void Boil() = 0;
//冲泡
virtual void Brew() = 0;
//倒入杯中
virtual void PourInCup() = 0;
//加点辅料
virtual void addSonm() = 0;
//模板方法:把调用函数的顺序确定下来
void func()
{
Boil();
Brew();
PourInCup();
addSonm();
}
};
int main()
{
system("pause");
return 0;
}

复制代码

六.虚析构函数和纯虚析构函数

虚析构函数:

为了解决基类指针指向派生类对象,并用基类指针释放派生类对象

纯虚析构函数:

有纯虚析构函数的类是抽象类,不能实例化对象

#define _CRT_SECIRE_NO_WARNINGS
#include <iostream>
using namespace std;
class Animal
{
public:
Animal()
{
cout << "Animal的构造" << endl;
}
A.虚析构函数:会调用子类的析构函数
//virtual ~Animal()
//{
// cout << "Animal的析构" << endl;
//}
//B.纯虚析构函数:需要在类外实现
virtual ~Animal() = 0;
};
Animal::~Animal()
{
cout << "Animal的析构" << endl;
}
class Son :public Animal
{
public:
Son()
{
cout << "Son的构造函数" << endl;
pName = new char[64];
memset(pName, 0, 64);
strcpy(pName, "如花");
}
~Son()
{
cout << "Son的析构函数" << endl;
if (pName!=NULL)
{
delete[] pName;
pName = NULL;
}
}
public:
char* pName;
};
void test()
{
//Animal a; //纯虚析构函数是抽象类,不能实例化对象
Animal* animal = new Son;
delete animal;
}
int main()
{
test();
system("pause");
return 0;
}

复制代码

七.父类引用子类对象

#define _CRT_SECIRE_NO_WARNINGS
#include <iostream>
using namespace std;
class Animal
{
public:
virtual void speak()
{
cout << "Animal speak()" << endl;
}
};
class Dog :public Animal
{
public:
virtual void speak()
{
cout << "Dog speak()" << endl;
}
};
void test()
{
Animal &animal = Dog();
animal.speak();
Animal* dog = new Dog();
Animal* &an = dog;
an->speak();
delete dog;
}
int main()
{
test();
system("pause");
return 0;
}

复制代码

八.重写,重载,重定义(隐蔽)

重载:

同一作用域的同名函数

重载(覆盖):

有继续
子类(派生类)重写父类(基类)的virtual函数
函数返回值,函数名字,函数参数,必须和基类中的虚函数一致

重定义(隐蔽):

有继续
子类(派生类)重新定义父类(基类)的同名成员(非virtual函数)

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

		自动登录	找回密码
密码			立即注册

C++[多态]

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

0 个回复

快速回复

楼主热帖

标签云

浏览过的版块