练习 ~黑马程序员匠心之作-第三阶段C++核心编程-P135~P142-类和对象-多态

最新推荐文章于 2023-12-25 00:43:34 发布
最新推荐文章于 2023-12-25 00:43:34 发布
阅读量523 收藏 8
点赞数
分类专栏： 黑马程序员匠心之作C++教程从0到1入门编程 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43964914/article/details/107585332
版权

黑马程序员匠心之作|C++教程从0到1入门编程

关于P135~P142-练习-类和对象-多态

1、多态的基本语法

多态是C++面向对象三大特性之一
多态分为两类

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

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

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

下面通过案例进行讲解多态

#include<iostream>
using namespace std;

//多态
//动物类
class Animal
{
public:
	//虚函数
	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}
};
//猫类
class Cat :public Animal
{
	//重写 函数返回值类型 函数名 参数列表 完全相同
	//此处virtual可写可不写
	void speak()
	{
		cout << "小猫在说话" << endl;
	}
};
//狗类
class Dog :public Animal
{
	void speak()
	{
		cout << "小狗在说话" << endl;
	}
};

//执行说话
//地址早绑定 在编译阶段就已经确定函数地址
//如果想执行让猫说话，那么这个函数地址就不能提前绑定，需要在运行阶段进行绑定，地址晚绑定

void doSpeak(Animal& animal)//Animal& animal=cat;父类引用指向子类对象
{
	animal.speak();
}
void test01()
{
	Cat cat;
	doSpeak(cat);

	Dog dog;
	doSpeak(dog);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

在这里插入图片描述
注意：
1、动态多态满足条件

  • 有继承关系
  • 子类重写父类的虚函数

2、动态多态的使用

  • 父类的指针或者引用 执行子类对象Animal& animal=cat;

3、重写

  • 函数返回值类型 函数名 参数列表完全一致称为重写

2、多态的原理剖析

对1、多态的基本语法的例子进行原理剖析
在这里插入图片描述
1、加virtual前后sizeof(Animal)的改变

  • 没有加virtual时sizeof(Animal)= 1
    非静态成员函数 不属于类的对象上，空对象占用内存空间为：1
    C++编译器会给每个空对象也分配一个字节空间，是为了区分空对象占内存位置
    在这里插入图片描述
  • 加virtual时sizeof(Animal)= 4，证明在Animal类中增加了一个指针，虚函数指针
    vfptr——虚函数（表）指针
    v——virtual 虚拟
    f——function 函数
    ptr——pointer 指针
    vftable——虚函数列表
    在这里插入图片描述

2、Cat类重写前后虚函数列表的变化

  • Cat类没有进行重写的话，继承父类的指针，占4个字节，继承的父类中的函数Animal::speak
    在这里插入图片描述
  • Cat类进行重写的话，继承父类的指针，占4个字节，但是指针指向的表中记录的数据有所变化，变为了子类自己的函数Cat::speak
    在这里插入图片描述

3、案例1-计算器类

案例描述：
分别利用普通写法和多态技术，设计实现两个操作数进行运算的计算器类
1、普通写法

#include<iostream>
#include<string>
using namespace std;
//利用普通写法和多态技术实现计算器
//普通写法
class Calculater
{
public:
	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;
	int m_Num2;
};
//多态技术
void test01()
{
	//创建计算器对象
	Calculater c;
	c.m_Num1 = 10;
	c.m_Num2 = 20;
	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;
}

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

在这里插入图片描述
注意：
如果想扩展新的功能，需求修改源码。在真的开发中 提倡 开闭原则
开闭原则：对扩展进行开放，对修改进行关闭
2、多态技术

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

//利用多态实现计算器
//实现计算器抽象类
class AbstractCalculator
{
public:
	virtual int getResult()
	{
		return 0;
	}
	int m_Num1;
	int m_Num2;
};
//加法计算器类
class AddCalculator :public AbstractCalculator
{
public:
	int getResult()
	{
		return m_Num1 + m_Num2;
	}
};
//减法计算器类
class SubCalculator :public AbstractCalculator
{
public:
	int getResult()
	{
		return m_Num1 - m_Num2;
	}
};
//乘法计算器类
class MulCalculator :public AbstractCalculator
{
public:
	int getResult()
	{
		return m_Num1 * m_Num2;
	}
};
void test02()
{
	//多态的使用条件
	//父类指针或引用指向子类对象

	//加法运算
	AbstractCalculator* abc = new AddCalculator;
	abc->m_Num1 = 10;
	abc->m_Num2 = 20;
	cout << abc->m_Num1 << " + " << abc->m_Num2 << " = " << abc->getResult() << endl;
	//用完后记得销毁，销毁的是数据
	delete abc;
	
	//减法运算
	abc = new SubCalculator;
	abc->m_Num1 = 10;
	abc->m_Num2 = 20;
	cout << abc->m_Num1 << " - " << abc->m_Num2 << " = " << abc->getResult() << endl;
	//用完后记得销毁
	delete abc;

	//乘法运算
	abc = new MulCalculator;
	abc->m_Num1 = 10;
	abc->m_Num2 = 20;
	cout << abc->m_Num1 << " * " << abc->m_Num2 << " = " << abc->getResult() << endl;
	//用完后记得销毁
	delete abc;	
}
int main()
{
	//test01();
	test02();
	system("pause");
	return 0;
}

在这里插入图片描述
多态的优点：

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

4、纯虚函数和抽象类

在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容，因此可以将虚函数改为纯虚函数
纯虚函数语法：virtual 返回值类型 函数名 （参数列表）= 0;
当类中有了纯虚函数，这个类也称为抽象类

抽象类特点：

  • 无法实例化对象
  • 子类必须重写抽象类中的纯虚函数，否则也属于抽象类
#include<iostream>
#include<string>
using namespace std;

//纯虚函数和抽象类
class Base
{
public:
	//纯虚函数
	//只要有一个纯虚函数，这个类称为抽象类
	//抽象类特点：
	//1、无法实例化对象
    //2、抽象类的子类 必须要重写父类中的纯虚函数，否则也属于抽象类
	virtual void func() = 0;

};
class Son :public Base
{
public:
	void func()
	{
		cout << "func()函数调用" << endl;
	}
};
void test01()
{
	//Base b;//报错，抽象类无法实例化对象
	//new Base;//堆区也不可以
	//Son s;//必须要重写父类中的纯虚函数，否则无法实例化对象
	Base *b = new Son;
	b->func();
	delete b;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

5、案例2-制作饮品

案例描述：
制作饮品的大致流程为：煮水-冲泡-倒入杯中-加入辅料
利用多态技术实现本案例，提供抽象制作饮品基类，提供子类制作咖啡和茶叶
在这里插入图片描述

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

//案例2制作饮品
//大致流程为：煮水-冲泡-倒入杯中-加入辅料
//利用多态技术实现本案例，提供抽象制作饮品基类，提供子类制作咖啡和茶叶
class AbstractDringking
{
public:
	//煮水
	virtual void Boil() = 0;
	//冲泡
	virtual void Brew() = 0;
	//倒入杯中
	virtual void PourInCup() = 0;
	//加入辅料
	virtual void PutSomething() = 0;
	//制作饮品
	void makeDrinking()
	{
		Boil() ;
		Brew() ;
		PourInCup() ;
		PutSomething() ;

	 }

};

//制作咖啡
class Coffee :public AbstractDringking
{
public:
	//煮水
	virtual void Boil()
	{
		cout << "煮水" << endl;
	}
	//冲泡
	virtual void Brew() 
	{
		cout << "冲泡咖啡" << endl;
	}
	//倒入杯中
	virtual void PourInCup() 
	{
		cout << "倒入杯中" << endl;
	}
	//加入辅料
	virtual void PutSomething() 
	{
		cout << "加糖和牛奶" << endl;
	}
};
//制作茶
class Tea :public AbstractDringking
{
public:
	//煮水
	virtual void Boil() 
	{
		cout << "煮水" << endl;
	}
	//冲泡
	virtual void Brew()
	{
		cout << "冲泡茶叶" << endl;
	}
	//倒入杯中
	virtual void PourInCup()
	{
		cout << "倒入杯中" << endl;
	}
	//加入辅料
	virtual void PutSomething() 
	{
		cout << "加柠檬" << endl;
	}
		
};

//制作饮品
void doWork(AbstractDringking* abd)
{
	abd->makeDrinking();
	delete abd;
}

void test01()
{
	doWork(new Coffee);

	cout << endl;

	doWork(new Tea);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

在这里插入图片描述

6、虚析构和纯虚析构

问题：多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码
解决方式：将父类中的析构函数改为虚析构或者纯虚析构

虚析构和纯虚析构共性：

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

虚析构和纯虚析构区别：

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

析构语法：virtual ~类名(){}
纯虚析构语法：virtual ~类名()=0; 类名::~类名(){}

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

//虚析构和纯虚析构
class Animal
{
public:
	Animal()
	{
		cout << "Animal的构造函数调用" << endl;
	}
	virtual void speak() = 0;
	//利用虚析构可以解决 父类指针释放子类对象时不干净的问题
	/*virtual ~Animal()
	{
		cout << "Animal的虚析构函数调用" << endl;
	}*/

	//纯虚析构 需要声明也需要实现
	//有了纯虚析构之后，这个类也属于抽象类，无法实例化对象
	virtual ~Animal() = 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()
	{
		cout << "Cat的析构函数调用" << endl;
		if (m_Name != NULL)
		{
			delete m_Name;
			m_Name = NULL;
		}
		
	}
	string* m_Name;
};

void test01()
{
	Animal *animal =new Cat("Tom");
	animal->speak();
	//父类指针在析构的时候 不会调用子类中的析构函数，导致子类中有堆区属性，出现内存泄漏
	//在基类中的析构函数前加virtual可以解决，变成虚析构，会调用子类的析构函数
	delete animal;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

没在析构函数前加virtual时：
在这里插入图片描述
在析构函数前加virtual，调用虚析构时：
在这里插入图片描述
在析构函数前加virtual，调用纯虚析构时：
在这里插入图片描述
注意：
1、虚析构或纯虚析构就是用来解决通过父类指针释放子类对象
2、如果子类中没有堆区数据，可以不写为虚析构或纯虚析构
3、拥有纯虚析构函数的类也属于抽象类，无法实例化对象，子类必须重写，不重写的话仍旧为抽象类，无法实例化对象

7、案例3-电脑组装需求分析

案例描述：
电脑主要组成部件为CPU（用于计算），显卡（用于显示），内存条（用于存储）
将每个零件封装出抽象基类，并且提供不同的厂商生产不同的零件，例如Intel厂商和Lenovo厂商
创建电脑类提供让电脑工作的函数，并且调用每个零件工作的接口
测试时组装三台不同的电脑进行工作
在这里插入图片描述

8、案例3-电脑组装具体实现

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

//一、电脑主要组成部件为CPU（用于计算），显卡（用于显示），内存条（用于存储）
//1、CPU（用于计算）
class CPU
{
public:
	//抽象计算函数
	virtual void calculate() = 0;
};
//2、显卡（用于显示）
class VideoCard
{
public:
	//抽象显示函数
	virtual void display() = 0;
};
//3、内存条（用于存储）
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_vc->display();
		m_mem->storage();
	}
	//提供析构函数 释放3个电脑零件
	~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厂商和Lenovo厂商
//1、Intel厂商
class IntelCPU :public CPU
{
public:
	virtual void calculate()
	{
		cout << "Intel的CPU开始计算了" << endl;
	}
};
class IntelVideoCard :public VideoCard
{
public:
	virtual void display() 
	{
		cout << "Intel的VideoCard开始显示了" << endl;
	}
};
class IntelMemory :public Memory
{
public:
	virtual void storage() 
	{
		cout << "Intel的Memory开始存储了" << endl;
	}
};
//2、Lenovo厂商
class LenovoCPU :public CPU
{
public:
	virtual void calculate()
	{
		cout << "Lenovo的CPU开始计算了" << endl;
	}
};
class LenovoVideoCard :public VideoCard
{
public:
	virtual void display()
	{
		cout << "Lenovo的VideoCard开始显示了" << endl;
	}
};
class LenovoMemory :public Memory
{
public:
	virtual void storage()
	{
		cout << "Lenovo的Memory开始存储了" << endl;
	}
};

//四、测试时组装三台不同的电脑进行工作
void test01()
{
	//这种方法也可，不如下面的直观
	/*IntelCPU icpu;
	IntelVideoCard ivc;
	IntelMemory imem;
	Computer c1(&icpu, &ivc, &imem);
	c1.work();*/

	cout << "第一台电脑开始工作：" << endl;
	//第一台电脑组装
	//第一台电脑零件
	CPU * IntelCpu = new IntelCPU;
	VideoCard * IntelCard = new IntelVideoCard;
	Memory * IntelMem = new IntelMemory;
	//创建第一台电脑
	Computer * computer1=new Computer(IntelCpu, IntelCard, IntelMem);
	computer1->work();
	delete computer1;
	/*delete IntelCpu;
	delete IntelCard;
	delete IntelMem;*///在Computer类中直接析构函数释放
	cout << "————————--————————————" << endl;

	cout << "第二台电脑开始工作：" << endl;
	//第二台电脑组装
	Computer * computer2 = new Computer(new LenovoCPU, new LenovoVideoCard, new LenovoMemory);
	computer2->work();
	delete computer2;
	cout << "————————--————————————" << endl;

	cout << "第三台电脑开始工作：" << endl;
	//第三台电脑组装
	Computer * computer3= new Computer(new LenovoCPU, new IntelVideoCard, new LenovoMemory);
	computer3->work();
	delete computer3;
	cout << "————————--————————————" << endl;
}

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

在这里插入图片描述
注意：
1、零件层都是抽象出来的，抽象出来的基类，不同的厂商来实现不同的具体的零件；零件里面都是纯虚函数，不需要写函数实现，具体的厂商才写具体的实现；
2、电脑类中，三个指针接受三个零件，三个零件通过一个work函数来工作起来，在此开始有多态概念；三个父类指针在调用接口的时候其实就是多态，因为传的肯定是子类对象，传的不同的子类对象会调用不同的函数
3、手动开辟的堆区空间，记得手动释放

lilyfengli
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++学习（第11天）黑马程序案例分析
纯粹的博客
05-26 252
第1个案例：设计正方体类 第2个案例：点和圆的关系 第1个案例：设计立方体类 设计正方体(Cube)，求出正方体的面积和体积，分别用全局函数和成员函数判断两个正方体是否相等 #include<iostream> #include<string> using namespace std; class Cube { public: void setLength(int a) { side_length = a; } int getLength() { retur
《黑马》——C++核心编程
热门推荐
漏网小鱼的博客
09-05 21万+
前言： ** 配套视频： https://www.bilibili.com/video/BV1et411b73Z?from=search&seid=16795623907667609637 只是为方便学习，不做其他用途，在此发布C++基础入门部分配套讲义，原作者为黑马程序 C++核心编程 本阶段主要针对C++面向对象编程技术做详细讲解，探讨C++中的核心和精髓。 1 内存分区模型 C++程序在执行时，将内存大方向划分为4个区域 代码区：存放函数体的二进制代码，由操作系统进行管理的 全局区：存放全局
C++核心编程
idefined的博客
05-07 267
C++核心编程 本阶段主要针对C++面向对象编程技术做详细讲解，探讨C++中的核心和精髓。 1 内存分区模型 C++程序在执行时，将内存大方向划分为4个区域 代码区：存放函数体的二进制代码，由操作系统进行管理的 全局区：存放全局变量和静态变量以及常量 栈区：由编译器自动分配释放, 存放函数的参数值,局部变量等 堆区：由程序员分配和释放,若程序员不释放,程序结束时由操作系统回收 内存四区意义： ...
B站黑马c++学习笔记 —— 核心编程篇
qq_52382976的博客
11-12 1469
大纲1 内存分区模型1.1 程序运行前1.2 程序运行后1.3 new操作符2 引用3 函数提高4 类和对象5 文件操作 1 内存分区模型 1.1 程序运行前 1.2 程序运行后 1.3 new操作符 2 引用 3 函数提高 4 类和对象 5 文件操作 ...
黑马程序员匠心之作 C++教程_第4阶段实战-基于多态的企业职工系统讲义.rar
03-19
《C++教程_第4阶段实战-基于多态的企业职工系统讲义》是黑马程序员精心制作的一份教学资源，特别适合C++初学者。这份讲义深入浅出地讲解了C++编程语言中的多态性，并通过实战项目——企业职工系统，让学习者能够将...
黑马程序员匠心之作 C++教程_第5阶段-C++提高编程资料讲义.rar
03-19
《黑马程序员匠心之作 C++教程_第5阶段-C++提高编程资料讲义》是一份针对C++编程初学者精心制作的教程资料，旨在帮助学习者深入理解和提升C++编程技能。这份讲义涵盖了许多关键的C++知识点，下面将对其进行详细解读...
黑马程序员匠心之作 C++教程_第7阶段-C++实战项目机房预约讲义.rar
03-19
《黑马程序员匠心之作 C++教程_第7阶段-C++实战项目机房预约讲义》是为C++初学者量身定制的一份详细教学资源。这份讲义深入浅出地介绍了C++编程语言，并通过实际的机房预约系统项目，帮助学习者将理论知识与实践相...
B站《黑马程序员匠心之作-C++教程从0到1入门编程,学习编程不再难》 配套笔记
07-31
【标题】：“B站《黑马程序员匠心之作-C++教程从0到1入门编程,学习编程不再难》 配套笔记” 【描述】提及的是一个针对初学者的C++教学资源，来自B站上的视频课程“BV1et411b73Z”。这门课程的特色在于提供了一份...
【讲义】匠心精作C++从0到1入门编程-学习编程不再难.zip
09-18
4. **第3阶段-C++核心编程 资料**：这一阶段深入讲解C++的核心概念，如类与对象、继承、多态性、模板等面向对象编程特性。理解这些概念对于编写复杂、可维护的代码至关重要。 5. **第4阶段实战-基于多态的企业职工...
传智播客旗下黑马程序员c++视频课程内部讲义
04-16
传智播客旗下黑马程序员c++视频课程内部讲义 就是上课时老师翻阅的那个讲义
C++核心编程.md
07-30
内存分区模型 程序运行前 程序运行后 new操作符 引用 引用的基本使用 引用注意事项 引用做函数参数 引用做函数返回值 引用的本质 常量引用 函数提高 类和对象 文件操作
C++_类和对象_C++多态_案例3-电脑组装---C++语言工作笔记075
添柴程序猿的专栏
06-17 273
然后我们再来看一个案例,这个案例,会把大体的代码写一下,然后 后面的内容,可以做为练习,自己实现. 可以看到,如果我们要组装一台电脑的话,首先, 我们有个,CPU的抽象类,有个显卡的抽象类,有个内存条的抽象类. 然后,我们用不同的厂商类,继承CPU / 显卡 /内存条 抽象类,来实现生产不同的 CPU 显卡 内存. 然后我们,再用一个Computer类, 传入CPU 显卡 内存条的指针,来组装一台电脑. 然后在Computer类中,再去提供一个work工作的方法,调用不同...
组装一台计算机
weixin_30480583的博客
07-19 261
//实现显示CUP内存的功能 package zuoye03; public interface CPU { public String pingPai(); public String zhuPing(); } //实现显示内存的功能 package zuoye03; public interface Nei...
C++学习全记录（全）
qq_41918369的博客
04-03 1330
C++核心编程 本阶段主要针对C++面向对象编程技术做详细讲解，探讨C++中的核心和精髓。 1 内存分区模型 C++程序在执行时，将内存大方向划分为4个区域 代码区：存放函数体的二进制代码，由操作系统进行管理的 全局区：存放全局变量和静态变量以及常量 栈区：由编译器自动分配释放, 存放函数的参数值,局部变量等 堆区：由程序员分配和释放,若程序员不释放,程序结束时由操作系统回收 内存四区意义： 不同区域存放的数据，赋予不同的生命周期, 给我们更大的灵活编程 1.1 程序运行前 ​ 在程序编译后，生成了ex
黑马程序员C++核心编程
最新发布
weixin_73900785的博客
12-25 1062
作用：函数名可以相同，提高复用性同一个作用域下函数名相同函数类型不同或个数不同或顺序不同函数的返回值不可以作为函数重载的条件​//函数重载满足条件：​//+同一个作用域下//+ 函数名相同//+ 函数 类型不同 或 个数不同 或 顺序不同 * *​//都是全局作用域，函数名相同，cout
C++核心编程（黑马程序员笔记）
qq_46210601的博客
04-25 340
这篇文章是看黑马程序员的C++课程后的笔记与总结
56_02 C++ 多态实例练习3 组装电脑
MakChiKin
09-01 362
案例描述： 电脑主要组成部件为 CPU（用于计算），显卡（用于显示），内存条（用于存储） 将每个零件封装出抽象基类，并且提供不同的厂商生产不同的零件，例如Intel厂商和Lenovo厂商 创建电脑类提供让电脑工作的函数，并且调用每个零件工作的接口 测试时组装三台不同的电脑进行工作 #include"inherit_10.h" // CPU抽象类 class CPU { public: virtual void calculate() = 0;// 虚构函数 }; // 显卡抽象类 ...
练习 ~黑马程序员匠心之作-第二阶段实战-P72~P83-通讯录管理系统
qq_43964914的博客
07-12 1159
黑马程序员匠心之作|C++教程从0到1入门编程 关于P72~P83-练习-通讯录管理系统1、系统功能介绍2、创建项目3、菜单功能4、退出功能实现5、添加联系人-结构体设计6、添加联系人-功能实现7、显示联系人8、删除联系人-检测联系人是否存在9、删除联系人-功能实现10、查找联系人11、修改联系人12、清空联系人 1、系统功能介绍 系统需求： 通讯录是一个可以记录亲人、好友信息的工具。本教程主要利用C++来实现一个通讯录管理系统系统中需实现的功能如下： 1、添加联系人：向通讯录中添加新人，信息包括(姓名、性
C 程序设计：第10章 多态.ppt
05-15
C 程序设计：第10章 多态.ppt

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值