C++基础07-静态联编和动态联编，多态，抽象类和纯虚函数，向上类型转换和向下类型转换

最新推荐文章于 2024-05-12 16:31:11 发布
最新推荐文章于 2024-05-12 16:31:11 发布
阅读量207 收藏
点赞数
分类专栏： # C++语言 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41865866/article/details/126456640
版权

01 静态联编和动态联编

概念:

1.多态是面向对象程序设计语言中数据抽象和继承之外的第三个基本特征。
2.C++支持编译时多态（静态多态）和运行时多态（动态多态），运算符和函数重载就是编译时多态，而派生类和虚函数实现运行时多态。
3.静态多态和动态多态的区别就是函数地址是早绑定（静态联编）还是晚绑定（动态联编）。
4.如果函数的调用在编译阶段就能确定函数的调用地址，并产生代码，就是静态多态（编译时多态），就是说地址是早绑定的。而如果函数的调用地址不能在编译期间确定，而需要在需要在运行时才能决定，就属于晚绑定（动态多态，运行时多态）。

1.如果发生了继承的关系，编译器允许进行类型转换

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Animal
{
public:
	void speak()
	{
		cout << "动物在说话" << endl;
	}

};

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

void doSpeak(Animal& animal)
{
	animal.speak();
}

//如果发生了继承的关系，编译器允许进行类型转换
void test01()
{
	Cat cat;
	doSpeak(cat);
}

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

在这里插入图片描述

2.动态联编

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Animal
{
public:
	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}

};

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

//调用doSpeak ，speak函数的地址早就绑定好了（早绑定，静态联编，编译阶段就确定好了地址）
//如果想调用猫的speak，不能提前绑定好函数的地址，所以需要在运行时候再去确定函数地址
//动态联编，写法 doSpeak 方法改为虚函数，在父类上声明虚函数，发生了多态
//多态：父类的引用或者指针 指向 子类对象
void doSpeak(Animal& animal) //Animal & animal = cat
{
	animal.speak();
}

//如果发生了继承的关系，编译器允许进行类型转换
void test01()
{
	Cat cat;
	doSpeak(cat);
}

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

在这里插入图片描述
注意：子函数的virtual可写可不写

02 多态原理解析

不写虚函数:

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Animal
{
public:
	void speak()
	{
		cout << "动物在说话" << endl;
	}

};

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

//调用doSpeak ，speak函数的地址早就绑定好了（早绑定，静态联编，编译阶段就确定好了地址）
//如果想调用猫的speak，不能提前绑定好函数的地址，所以需要在运行时候再去确定函数地址
//动态联编，写法 doSpeak 方法改为虚函数，在父类上声明虚函数，发生了多态
//多态：父类的引用或者指针 指向 子类对象
void doSpeak(Animal& animal) //Animal & animal = cat
{
	animal.speak();
}

//如果发生了继承的关系，编译器允许进行类型转换
void test01()
{
	Cat cat;
	doSpeak(cat);
}

void test02()
{
	cout << sizeof(Animal) << endl;
} 
int main(void)
{
	test02();
	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述
写vitrual:

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Animal
{
public:
	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}

};

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

//调用doSpeak ，speak函数的地址早就绑定好了（早绑定，静态联编，编译阶段就确定好了地址）
//如果想调用猫的speak，不能提前绑定好函数的地址，所以需要在运行时候再去确定函数地址
//动态联编，写法 doSpeak 方法改为虚函数，在父类上声明虚函数，发生了多态
//多态：父类的引用或者指针 指向 子类对象
void doSpeak(Animal& animal) //Animal & animal = cat
{
	animal.speak();
}

//如果发生了继承的关系，编译器允许进行类型转换
void test01()
{
	Cat cat;
	doSpeak(cat);
}

void test02()
{
	cout << sizeof(Animal) << endl;
} 
int main(void)
{
	test02();
	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述
继承但未重写前：
在这里插入图片描述
当speak()重写后:
在这里插入图片描述
重写前的对象模型：
在这里插入图片描述
重写后的对象模型：
在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Animal
{
public:
	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}

};

class Cat :public Animal
{
public:
};

//调用doSpeak ，speak函数的地址早就绑定好了（早绑定，静态联编，编译阶段就确定好了地址）
//如果想调用猫的speak，不能提前绑定好函数的地址，所以需要在运行时候再去确定函数地址
//动态联编，写法 doSpeak 方法改为虚函数，在父类上声明虚函数，发生了多态
//多态：父类的引用或者指针 指向 子类对象
void doSpeak(Animal& animal) //Animal & animal = cat
{
	animal.speak();
}

//如果发生了继承的关系，编译器允许进行类型转换
void test01()
{
	Cat cat;
	doSpeak(cat);
}

void test02()
{
	//cout << sizeof(Animal) << endl;
	//分类指针指向子类对象，多态
	Animal* animal = new Cat;
	animal->speak();
	//* (int*)*(int*)animal 函数地址
	//(void(*)()) 函数指针
	((void(*)()) (*(int*)*(int*)animal))();
} 
int main(void)
{
	test02();
	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述
总结:

  • 当父类中有了虚函数之后，内部结构就发生了改变
  • 内部多了一个vfptr（virtual function pointer）虚函数指针，指向vftable
  • 父类中 进行继承时， 会继承vfptr vftable
  • 构造函数中 会将虚函数指针指向自己的虚函数表
  • 如果发生了重写，会替换掉虚函数表中的原有的函数，改为自己的函数调用地址

增加eat()函数:

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Animal
{
public:
	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}

	virtual void eat()
	{
		cout << "动物在吃东西" << endl;
	}

};

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

//调用doSpeak ，speak函数的地址早就绑定好了（早绑定，静态联编，编译阶段就确定好了地址）
//如果想调用猫的speak，不能提前绑定好函数的地址，所以需要在运行时候再去确定函数地址
//动态联编，写法 doSpeak 方法改为虚函数，在父类上声明虚函数，发生了多态
//多态：父类的引用或者指针 指向 子类对象
void doSpeak(Animal& animal) //Animal & animal = cat
{
	animal.speak();
}

//如果发生了继承的关系，编译器允许进行类型转换
void test01()
{
	Cat cat;
	doSpeak(cat);
}

void test02()
{
	//cout << sizeof(Animal) << endl;
	//分类指针指向子类对象，多态
	Animal* animal = new Cat;
	animal->speak();
	//* (int*)*(int*)animal 函数地址
	//(void(*)()) 函数指针
	((void(*)()) (*(int*)*(int*)animal))();
	
	//*((int*)*(int*)animal+1) 小猫吃鱼的地址
	((void(*)()) (*((int*)*(int*)animal + 1)))();
 
} 
int main(void)
{
	test02();
	system("pause");
	return EXIT_SUCCESS;
}

对象模型:
在这里插入图片描述

03 多态案例-计算器案例

多态成立的条件：

1.有继承
2.子类重写父类虚函数函数（返回值，函数名字，函数参数，必须和父类完全一致（析构函数除外））
3.类型兼容，父类指针、父类引用 指向 子类对象

开发原则：

开闭原则（对扩展开放，对修改关闭）

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

//利用多态实现计算器
class abstrackCalculator
{
public:
	abstrackCalculator() :val1(1), val2(1) {}

public:
	//虚函数
	virtual int getResult()
	{
		return 0;
	}

	void setVal1(int v)
	{
		this->val1 = v;
	}
	void setVal2(int v)
	{
		this->val2 = v;
	}
public:
	int val1;
	int val2;
};

class addCalculator :public abstrackCalculator
{
public:
	virtual int getResult()
	{
		return val1 + val2;
	}
};

class subCalculator :public abstrackCalculator
{
public:
	virtual int getResult()
	{
		return val1 - val2;
	}
};

class mulCalculator :public abstrackCalculator
{
public:
	virtual int getResult()
	{
		return val1 * val2;
	}
};

//真正的开发中，有个开发原则（开闭原则）
//对扩展开放 对修改关闭
void test02()
{
	abstrackCalculator* abs;
	abs = new addCalculator;
	abs->setVal1(105);
	abs->setVal2(200);
	cout << abs->getResult() << endl;
	delete abs;

	abs = new subCalculator;
	abs->setVal1(105);
	abs->setVal2(200);
	cout << abs->getResult() << endl;
	delete abs;

	abs = new mulCalculator;
	abs->setVal1(105);
	abs->setVal2(200);
	cout << abs->getResult() << endl;
	delete abs;
}

int main(void)
{
	test02();
	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述

04 抽象类和纯虚函数

纯虚函数：

1.如果父类中存在纯虚函数，子类继承父类，就必须要实现 纯虚函数
2.如果父类中有了纯虚函数，就不可以实例化对象了
3.这个类有了纯虚函数，通常又称为 抽象类

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

//利用多态实现计算器
class abstrackCalculator
{
public:
	abstrackCalculator() :val1(1), val2(1) {}

public:
	//虚函数
	/*virtual int getResult()
	{
		return 0;
	}*/

	//纯虚函数
	//如果父类中存在纯虚函数，子类继承父类，就必须要实现 纯虚函数
	//如果父类中有了纯虚函数，就不可以实例化对象了
	//这个类有了纯虚函数，通常又称为 抽象类
	virtual int getResult() = 0;

	void setVal1(int v)
	{
		this->val1 = v;
	}
	void setVal2(int v)
	{
		this->val2 = v;
	}
public:
	int val1;
	int val2;
};

class addCalculator :public abstrackCalculator
{
public:
	virtual int getResult()
	{
		return val1 + val2;
	}
};

class subCalculator :public abstrackCalculator
{
public:
	virtual int getResult()
	{
		return val1 - val2;
	}
};

class mulCalculator :public abstrackCalculator
{
public:
	virtual int getResult()
	{
		return val1 * val2;
	}
};

//真正的开发中，有个开发原则（开闭原则）
//对扩展开放 对修改关闭
void test02()
{
	abstrackCalculator* abs;
	abs = new addCalculator;
	abs->setVal1(105);
	abs->setVal2(200);
	cout << abs->getResult() << endl;
	delete abs;

	abs = new subCalculator;
	abs->setVal1(105);
	abs->setVal2(200);
	cout << abs->getResult() << endl;
	delete abs;

	abs = new mulCalculator;
	abs->setVal1(105);
	abs->setVal2(200);
	cout << abs->getResult() << endl;
	delete abs;
}

int main(void)
{
	test02();
	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述

05 虚析构和纯虚析构

1.普通析构 是不会调用子类析构的，所以可能导致释放不干净，利用虚析构来解决这个问题

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Animal
{
public:
	virtual void speak() = 0;

public:
	//普通析构 是不会调用子类析构的，所以可能导致释放不干净
	 ~Animal()
	{
		cout << "Animal析构函数调用" << endl;
	}

};

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

	Cat(const char* name)
	{
		this->m_Name = new char[strlen(name) + 1];
		strcpy(this->m_Name, name);
	}

	~Cat()
	{
		cout << "Cat析构函数调用" << endl;
		if (this->m_Name != NULL)
		{
			delete[] this->m_Name;
			this->m_Name = NULL;
		}
	}
public:
	char* m_Name;
};

void test01()
{
	Animal* animal = new Cat("Tom");
	animal->speak();

	delete animal;
}

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

在这里插入图片描述
普通析构 是不会调用子类析构的，所以可能导致释放不干净，利用虚析构来解决这个问题

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Animal
{
public:
	virtual void speak() = 0;

public:
	//普通析构 是不会调用子类析构的，所以可能导致释放不干净
	//利用虚析构来解决这个问题
	virtual ~Animal()
	{
		cout << "Animal析构函数调用" << endl;
	}

};

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

	Cat(const char* name)
	{
		this->m_Name = new char[strlen(name) + 1];
		strcpy(this->m_Name, name);
	}

	~Cat()
	{
		cout << "Cat析构函数调用" << endl;
		if (this->m_Name != NULL)
		{
			delete[] this->m_Name;
			this->m_Name = NULL;
		}
	}
public:
	char* m_Name;
};

void test01()
{
	Animal* animal = new Cat("Tom");
	animal->speak();

	delete animal;
}

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

在这里插入图片描述

2.纯虚析构

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Animal
{
public:
	virtual void speak() = 0;

public:
	//普通析构 是不会调用子类析构的，所以可能导致释放不干净
	//利用虚析构来解决这个问题
	/*virtual ~Animal()
	{
		cout << "Animal析构函数调用" << endl;
	}*/

	//纯虚析构
	//如果函数中出现了 纯虚析构函数，那么这个类也算抽象类
	//抽象类不可以实例化
	virtual ~Animal() = 0;

};
Animal::~Animal()
{
	cout << "Animal 的纯虚析构函数调用" << endl;
}

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

	Cat(const char* name)
	{
		this->m_Name = new char[strlen(name) + 1];
		strcpy(this->m_Name, name);
	}

	~Cat()
	{
		cout << "Cat析构函数调用" << endl;
		if (this->m_Name != NULL)
		{
			delete[] this->m_Name;
			this->m_Name = NULL;
		}
	}
public:
	char* m_Name;
};

void test01()
{
	Animal* cat1 = new Cat("Tom");
	cat1->speak();

	delete cat1;
}

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

在这里插入图片描述

06 向上类型转换和向下类型转换

基类转派生类：向下类型转换 不安全的
派生类转基类：向上类型转换 安全的
如果发生了多态：总是安全的

原理如下:
在这里插入图片描述

07 多态案例二-PK小游戏

1.需求

在这里插入图片描述

2.游戏构建及运行

Weapon.h：

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

//抽象类
class Weapon
{
public:
	//获取基础伤害
	virtual int getBaseDamage() = 0;

	// 获取吸血
	virtual int getSuckBlood() = 0;

	// 获取是否定身
	virtual bool getHold() = 0;

	// 获取是否暴击
	virtual bool getCrit() = 0;

	string m_WeaponName; //武器名称
	int m_BaseDamage; //基础伤害
};

Knife.h：

#pragma once
#include<iostream>
#include<string>
using namespace std;
#include "Weapon.h"

class Knife :public Weapon
{
public:
	Knife();
	//获取基础伤害
	virtual int getBaseDamage();

	// 获取吸血
	virtual int getSuckBlood();

	// 获取是否定身
	virtual bool getHold();

	// 获取是否暴击
	virtual bool getCrit();

};

Knife.cpp：

#include"Knife.h"

Knife::Knife()
{
	this->m_BaseDamage = 10;
	this->m_WeaponName = "小刀";
}

int Knife::getBaseDamage()
{
	return this->m_BaseDamage;
}

int Knife::getSuckBlood()
{
	return 0;
}

bool Knife::getHold()
{
	return false;
}

bool Knife::getCrit()
{
	return false;
}

DragonSword.h:

#pragma once
#include<iostream>
#include<string>
using namespace std;
#include "Weapon.h"

class DragonSword :public Weapon
{
public:
	DragonSword();
	//获取基础伤害
	virtual int getBaseDamage();

	// 获取吸血
	virtual int getSuckBlood();

	// 获取是否定身
	virtual bool getHold();

	// 获取是否暴击
	virtual bool getCrit();

	//吸血率 定身率 暴击率
	int suckRate;
	int holdRate;
	int critRate;

	//传入概率，判断是否触发
	bool isTrigger(int rate);

};

DragonSword.cpp：

#include"DragonSword.h"

DragonSword::DragonSword()
{
	this->m_BaseDamage = 20;
	this->m_WeaponName = "屠龙宝刀";
	this->suckRate = 20;
	this->holdRate = 30;
	this->critRate = 35;
}

int DragonSword::getBaseDamage()
{
	return this->m_BaseDamage;
}

int DragonSword::getSuckBlood()
{
	if (isTrigger(suckRate))
	{
		return this->m_BaseDamage * 0.5; //按照武器基础伤害一半吸血
	}
}

bool DragonSword::getHold()
{
	if (isTrigger(holdRate))
	{
		return true;
	}
	return false;
}

bool DragonSword::getCrit()
{
	if (isTrigger(critRate))
	{
		return true;
	}
	return false;
}

bool DragonSword::isTrigger(int rate)
{
	//通过isTrigger判断是否触发特效
	//随机1-100的数字
	int num = rand() % 100 + 1;
	if (num < rate) {
		return true;
	}
	return false;
}

Hero.h:

#pragma once
#include<iostream>
#include<string>
using namespace std;
#include "Weapon.h"
#include"Monster.h"

class Monster;
class Hero
{
public:
	Hero();

	string m_Name;//人名

	int m_Atk;//攻击力

	int m_Def;//防御力

	int m_Hp;//血量

	Weapon* weapon;//武器

	void EquipWeapon(Weapon* weapon);

	void Attack(Monster* monster);
};

Hero.cpp：

#include"Hero.h"

Hero::Hero()
{
	this->m_Hp = 500;
	this->m_Atk = 50;
	this->m_Def = 50;
	this->m_Name = "法师";
	this->weapon = NULL;
}

//装备武器
void Hero::EquipWeapon(Weapon* weapon)
{
	this->weapon = weapon;
	cout << "英雄:" << this->m_Name << "装备了武器<<" << this->weapon->m_WeaponName << ">>" << endl;
}

//攻击
void Hero::Attack(Monster* monster)
{
	int damage = 0;
	int addHp = 0;
	bool isHold = false;
	bool isCrit = false;

	if (this->weapon == NULL)//武器为空，没有加成
	{
		damage = this->m_Atk;
	}
	else
	{
		//基础伤害
		damage = this->m_Atk + this->weapon->getBaseDamage();
		//计算吸血
		addHp = this->weapon->getSuckBlood();
		//计算定身
		isHold = this->weapon->getHold();
		//计算暴击
		isCrit = this->weapon->getCrit();
	}
	if (isCrit)//暴击 伤害 加成
	{
		damage = damage * 2;
		cout << "英雄的武器触发了暴击效果，怪物受到了双倍的伤害，伤害值：" << damage << endl;
	}
	if (isHold)
	{
		cout << "英雄的武器触发了定身效果，怪物停止攻击一回合" << endl;
	}
	if (addHp > 0)
	{
		cout << "英雄的武器触发了吸血效果，英雄增加的血量为" << addHp << endl;
	}

	//计算怪物定身
	monster->m_Hold = isHold;
	
	//计算真实伤害
	int trueDamage = (damage - monster->m_Def) > 0 ? damage - monster->m_Def : 1;

	monster->m_Hp -= trueDamage;
	this->m_Hp += addHp;
	cout << "英雄" << this->m_Name << "攻击了敌人" << monster->m_Name << "造成了伤害" << trueDamage << endl;
}

Monster.h:

#pragma once
#include<iostream>
#include<string>
using namespace std;
#include "Weapon.h"
#include"Hero.h"

class Hero;
class Monster
{
public:
	Monster();

	string m_Name;//人名

	int m_Atk;//攻击力

	int m_Def;//防御力

	int m_Hp;//血量

	bool m_Hold;

	void Attack(Hero* hero);
};

Monster.cpp：

#include "Monster.h"

Monster::Monster()
{
	this->m_Hp = 300;
	this->m_Atk = 70;
	this->m_Def = 40;
	this->m_Hold = false;
	this->m_Name = "比克大魔王";
}

void Monster::Attack(Hero* hero)
{
	if (this->m_Hold)
	{
		cout << "怪物" << this->m_Name << "被定身了，本回合无法攻击" << endl;
		return;
	}
	//计算攻击伤害
	int damage = (this->m_Atk - hero->m_Def) > 0 ? this->m_Atk - hero->m_Def : 1;

	hero->m_Hp -= damage;
	cout << "怪物" << this->m_Name << "攻击了英雄" << hero->m_Name << "造成了伤害" << damage << endl;
}

多态案例二-PK小游戏.cpp：

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<ctime>
#include"Hero.h"
#include"Monster.h"
#include"Weapon.h"
#include"Knife.h"
#include"DragonSword.h"
using namespace std;

void play()
{
	//创建怪物
	Monster* monster = new Monster;
	//创建英雄
	Hero* hero = new Hero;

	//创建武器
	Weapon* knife = new Knife;
	Weapon* dragon = new DragonSword;

	//让用户选择武器
	cout << "请选择武器:" << endl;
	cout << "1.赤手空拳" << endl;
	cout << "2.小刀" << endl;
	cout << "1.屠龙刀" << endl;

	int oper;
	cin >> oper;
	switch (oper)
	{
	case 1:
		cout << "你真牛，你还是太年轻了！" << endl;
		break;
	case 2:
		hero->EquipWeapon(knife);
		break;
	case 3:
		hero->EquipWeapon(dragon);
		break;
	default:
		break;
	}

	getchar();//输入缓冲区里有个回车，多获取一次值，将回车获取掉
	int round = 1;
	while (true)
	{
		getchar();
		system("cls");//防止输出太快，回车清屏
		cout << "---当前第" << round << "回合开始---" << endl;
		if (hero->m_Hp <= 0)
		{
			cout << "英雄" << hero->m_Name << "已挂，游戏结束" << endl;
			break;
		}
		hero->Attack(monster);

		if (monster->m_Hp <= 0)
		{
			cout << "怪物" << monster->m_Name << "已挂，顺利通过" << endl;
			break;
		}
		monster->Attack(hero);
		if (hero->m_Hp <= 0)
		{
			cout << "英雄" << hero->m_Name << "已挂，游戏结束" << endl;
			break;
		}
		cout << "英雄" << hero->m_Name << "剩余血量:" << hero->m_Hp << endl;
		cout << "怪物" << monster->m_Name << "剩余血量:" << monster->m_Hp << endl;
		round++;
	}

	delete monster;
	delete hero;
	delete knife;
	delete dragon;
}

int main(void)
{
	srand((unsigned int)time(NULL));//定义随机种子
	play();
	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述
在这里插入图片描述

好奇养活小猫
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
解析C++中的虚拟函数及其静态类型和动态类型
12-31
虚拟函数是C++语言引入的一个很重要的特性，它提供了“动态绑定”机制，正是这一机制使得继承的语义变得相对明晰。 （1）基类抽象了通用的数据及操作，就数据而言，如果该数据成员在各派生类中都需要用到，那么就...
C++ 抽象基类
xiaogangjava的博客
04-29 3938
C++ 抽象基类 一、简介 抽象基类： abstract base class，简称ABC，只定义接口，而不涉及实现，主要用于定义派生类的通用接口。抽象基类必 须包含至少一个纯虚方法。且包含纯虚函数的抽象基类，不能用来创建对象，只能用作基类。 纯虚方法： 在函数声明的结尾处添加 =0，以表示此函数为纯虚函数。在当前类可不用给出实现。举例声明方式如下： // 纯虚函数 virtual void functionname() = 0; 二、举例说明 比方说有A、B两个类，最初的设计思想是B类继承A类，但是实际
从C到C++___类继承(二)动态联编与虚方法、抽象基类
m0_71009069的博客
08-04 237
类继承(二)动态联编与虚方法、抽象基类
C++基础篇之面试笔记-1
weixin_46417419的博客
09-07 163
{//=====面向对象 封装 继承 多态 -> 对人不对事 {//面向对象(对人) VS 面向过程(对事) C语言采用面向过程的方式，以过程为中心，将分析解决问题的步骤和流程以函数的方式实现。 C++采用面向对象的方式，以实物为中心，一切实物皆是对象，通过面向对象的方式，将现实世界抽象成对象。 {//例: 五子棋 面向过程(按步骤走) //1开始游戏 ->2黑子先走-> 3绘制画面 -> 4判断输赢 -> 5轮到白子 -> 6 绘制画面 -> 7判断输赢，8返
C++ ：多态（类型转换及问题、虚函数、C++如何实现动态绑定、多态成立的条件、抽象基类和纯虚函数、虚析构函数）
陈宸的博客
11-01 446
多态是面向对象程序设计语言中数据抽象和继承之外的第三个基本特征。 目录 一、类型转换及问题 1.2 问题解决思路 1.3 问题解决方案(虚函数,vitual function) 二、C++如何实现动态绑定 三、多态成立的条件 四、抽象基类和纯虚函数(pure virtual function) 五、虚析构函数 c++支持编译时多态(静态多态)和运行时多态(动态多态)，运算符...
C++的抽象基类
天才小熊猫
12-22 1574
抽象基类的定义： 当我们把类看作一种数据类型时，通常会认为该类肯定是要被实例为一个或多个对象的。但在很多情况下，定义那些不能实例化出对象的类是很有用的，例如一个抽象基类Shape的纯虚函数Draw（）它并不知道自己要画一个什么形状，具体画什么圆啊，矩形啊等等都由派生类决定。因此依据这个可以将类分为抽象类（不能实例对象）和具体类OR实现类（可以实例对象）。抽象类的唯一目的就是让其派生类继承并实现它的接口方法（例如上面谈到的Draw()），因此也通常被称为抽象基类。 抽象基类的创建 如果将基类的虚函数声明为纯虚
动态联编和静态联编、以及多态
A_ns_wer_的博客
03-12 1893
动态联编和静态联编 动态联编和静态联编的存在是为了支持C++的多态性。 静态联编：编译器在编译期就把对象与其在申明时采用的类型绑定起来，就确定函数的调用地址 class A { } class B:public A { } class D:public A { } void test() { D* d=new D;//静态联编会把d绑定在D*类型上，因为D*是d的声明类型 B* b=d;//静态联编会把b绑定在B*类型上 } 动态联编：编译器在运行期才把对象与其最后一个指向的类型
C++虚函数、多态、抽象类和强制类型转换
m0_37622246的博客
09-16 949
C++虚函数、多态、抽象类和强制类型转换虚函数什么是虚函数特点多态多态的条件在构造、析构函数中调用虚函数纯虚函数抽象类纯抽象类虚函数表什么是虚函数表 虚函数 什么是虚函数 类的成员函数前加virtual这种函数就叫虚函数 特点 子类会覆盖父类的虚函数 多态 当子类覆盖了父类的虚函数时，通过父类指针指向子类对象时，调用虚函数，会根据具体的对象是谁来决定执行谁的函数，这就是多态。 多态的条件 1、父子...
C++引入抽象基类和纯虚函数的作用和目的
qq_41687938的博客
04-15 1225
为什么要引入抽象基类和纯虚函数？主要目的是为了实现一种接口的效果。   原文链接：https://blog.csdn.net/weibo1230123/article/details/82014322 抽象类是一种特殊的类，它是为了抽象和设计的目的为建立的，它处于继承层次结构的较上层。       ⑴抽象类的定义：带有纯虚函数的类为抽象类。       ...
C++多态和抽象类
泠山的博客
07-27 746
C++多态和抽象类1. 多态1.1 虚函数概述 Reference: 明日科技 《零基础学 C++》 1. 多态 多态性(polumorphism) 是面向对象程序设计的一个重要特征，利用多态性可以设计和实现一个易于扩展的系统。在 C++ 语言中，多态性是指具有不同功能的函数可以用同一个函数名，这样就可以用一个函数名调用不同内容的函数。当发出同样的消息被不同类型的对象接收时，导致完全不同的行为。这里所说的消息主要指类的成员函数的调用，而不同的行为是指不同的实现。 多态性通过联编实现。联编是指一个计算机程
C++---静态多态与动态多态
热门推荐
江城的博客
08-02 4万+
多态 多态按字面的意思就是多种形态，相同的方法调用，但是有不同的实现方式。多态性可以简单地概括为“一个接口，多种方法”。 C++有两种多态形式： 静态多态 动态多态 静态多态 静态多态：也称为编译期间的多态，编译器在编译期间完成的，编译器根据函数实参的类型(可能会进行隐式类型转换)，可推断出要调用那个函数，如果有对应的函数就调用该函数，否则出现编译错误。 静态多态有两种实现方式...
详解C++纯虚函数与抽象类
01-19
为什么说虚函数是C++最重要的特性之一呢，因为虚函数承载着C++中动态联编的作用，也即多态，可以让程序在运行时选择合适的成员函数。虚函数必须是类的非静态成员函数（且非构造函数），其访问权限是public。那么： ...
C++多态的实现机制深入理解
12-26
在面试过程中C++的多态实现机制经常会被面试官问道。大家清楚多态到底该如何实现吗？下面小编抽空给大家介绍下多态的实现...6. 抽象类是指包括至少一个纯虚函数的类。 多态的简单介绍 一般来说，多态分为两种，静态
05 对象的初始化和清理.rar_C++
09-21
纯虚函数和抽象类；构造函数的分类及调用；构造函数和析构函数；继承；静态成员；拷贝构造函数调用；虚析构和纯虚析构；友元；运算符重载；多态及多态的三个案例：计算器类、制作饮品、电脑组装。
c++ 点到多边形的距离
jacke121的专栏
05-08 300
c++ 点到多边形的距离
C++关联容器unordered_map无法通过索引来访问元素
book_dw5189的博客
05-06 746
unordered_map 中的元素没有固定的顺序，插入元素的顺序和元素的键值大小没有关系，因此无法通过索引来访问元素。
2024OD机试卷-手机App防沉迷系统 (java\python\c++)
WRJ_Jack的博客
05-12 20
智能手机方便了我们生活的同时，也侵占了我们不少的时间。 “手机App防沉迷系统”能够让我们每天合理地规划手机App使用时间，在正确的时间做正确的事。 它的大概原理是这样的： 1. 在一天24小时内，可以注册每个App的允许使用时段 2. 一个时间段只能使用一个App，举例说明：不能同时在9:00-10:00注册App2和App3 3. App有优先级，数值越高，优先级越高。注册使用时段时，如果高优先级的App时间和低优先级的时段有冲突，则系统会自动注销低优先级的时段，如果App的优先级相 同，则后添加的Ap
C语言星号带括号的情形
bcbobo21cn的专栏
05-11 31
C语言星号，当星号右侧是一个指针变量，星号和指针变量可看作一个整体，表示的是指针变量所指的内容；
C++高精度算法-加法
最新发布
weixin_60673089的博客
05-12 336
当一个数很大无法被普通变量所表示（不包括特殊关键字，只谈论STL范围内的）那么，就要用一点歪招了，那就是用数组存储每个数位上的内容。如果强制表示，就会溢出，这里的溢出大家可以自行百度，反正就是会出一些-5665434之类的数。这的确是一个令人非常头疼的问题，不过只要按照，向下一位进位的法则，也就没有那么难了。在C++的运算中，难免会出现很大很大的数，下面是各个关键字的表示范围。1.因为最后一位也有进位，那么可能长度会+1,所以要写一个特判。这里需要注意的是，字符的下标是从0开始的，所以不要写成1了。
学习-java继承和多态之对象类型的转换
03-16
Java中的继承和多态允许在运行时将一个对象的类型转换为其父类或子类的类型。这称为向上转型(upcasting)和向下转型(downcasting)。 向上转型是将一个子类的对象转换为其父类的类型，这是自动进行的。例如，如果有一...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值