1.输入输出
1. cout 流出所以指向流出,为<<
2. cin 流入所以指向需要输入的信息,为>>
3. endl 就相当于换行。4. 在使用cin和cout的时候需要包含==头文件为include iostream>==以及需要展开以std标准命名空间的库函数。
#include<iostream>
using namespace std;
2.引用
作用: 给变量起别名语法: 数据类型 & 别名 = 原名
int main() {
int a = 10;
int &b = a;
cout << "a = " << a << endl;
cout << "b = " << b << endl;
b = 100;
cout << "a = " << a << endl;
cout << "b = " << b << endl;
system("pause");
return 0;
}
引用必须初始化引用在初始化后,不可以改变引用传参====地址传参
引用做函数返回值:作用:引用是可以作为函数的返回值存在的注意: 不要返回局部变量引用用法:函数调用作为左值
引用的本质在 c++ 内部实现是一个 指针常量 .
常量引用作用: 常量引用主要用来修饰形参,防止误操作在函数形参列表中,可以加 ==const 修饰形参 == ,防止形参改变实参int& ref = 10; // 引用本身需要一个合法的内存空间,因此这行错误// 加入 const 就可以了,编译器优化代码, int temp = 10; const int& ref = temp;const int & ref = 10 ;
3.函数提高
函数默认参数在 C++ 中,函数的形参列表中的形参是可以有默认值的。语法: 返回值类型 函数名 (参数 = 默认值) {}函数占位参数C++ 中函数的形参列表里可以有占位参数,用来做占位,调用函数时必须填补该位置语法: 返回值类型 函数名 ( 数据类型 ){}
int func(int a, int b = 10, int c = 10) {
return a + b + c;
}
//1. 如果某个位置参数有默认值,那么从这个位置往后,从左向右,必须都要有默认值
//2. 如果函数声明有默认值,函数实现的时候就不能有默认参数
int func2(int a = 10, int b = 10);
int func2(int a, int b) {
return a + b;
}
int main() {
cout << "ret = " << func(20, 20) << endl;
cout << "ret = " << func(100) << endl;
system("pause");
return 0;
}
//函数占位参数 ,占位参数也可以有默认参数
void func(int a, int) {
cout << "this is func" << endl;
}
int main() {
func(10,10); //占位参数必须填补
system("pause");
return 0;
}
函数重载作用: 函数名可以相同,提高复用性函数重载满足条件:同一个作用域下函数名称相同函数参数 类型不同 或者 个数不同 或者 顺序不同注意 : 函数的返回值不可以作为函数重载的条件
//函数重载需要函数都在同一个作用域下
void func()
{
cout << "func 的调用!" << endl;
}
void func(int a)
{
cout << "func (int a) 的调用!" << endl;
}
void func(double a)
{
cout << "func (double a)的调用!" << endl;
}
void func(int a ,double b)
{
cout << "func (int a ,double b) 的调用!" << endl;
}
void func(double a ,int b)
{
cout << "func (double a ,int b)的调用!" << endl;
}
//函数返回值不可以作为函数重载条件
//int func(double a, int b)
//{
// cout << "func (double a ,int b)的调用!" << endl;
//}
int main() {
func();
func(10);
func(3.14);
func(10,3.14);
func(3.14 , 10);
system("pause");
return 0;
}
引用作为函数重载条件:
//函数重载注意事项
//1、引用作为重载条件
void func(int &a)
{
cout << "func (int &a) 调用 " << endl;
}
void func(const int &a)
{
cout << "func (const int &a) 调用 " << endl;
}
//2、函数重载碰到函数默认参数
void func2(int a, int b = 10)
{
cout << "func2(int a, int b = 10) 调用" << endl;
}
void func2(int a)
{
cout << "func2(int a) 调用" << endl;
}
int main() {
int a = 10;
func(a); //调用无const
func(10);//调用有const
//func2(10); //碰到默认参数产生歧义,需要避免
system("pause");
return 0;
}
4.类和对象
C++ 面向对象的三大特性为: == 封装、继承、多态 ==
4.1封装
封装的意义:将属性和行为作为一个整体,表现生活中的事物将属性和行为加以权限控制封装意义一:在设计类的时候,属性和行为写在一起,表现事物语法: class 类名 { 访问权限: 属性 / 行为 } ;封装意义二:类在设计时,可以把属性和行为放在不同的权限下,加以控制 访问权限有三种:公共权限 public 类内可以访问 类外可以访问保护权限 protected 类内可以访问 类外不可以访问私有权限 private 类内可以访问 类外不可以访问
struct 和 class 区别在 C++ 中 struct 和 class 唯一的 区别 就在于 默认的访问权限不同区别:struct 默认权限为公共class 默认权限为私有
优点 1 : 将所有成员属性设置为私有,可以自己控制读写权限优点 2 : 对于写权限,我们可以检测数据的有效性
练习案例
1
:设计立方体类
设计立方体类
(Cube)
求出立方体的面积和体积
分别用全局函数和成员函数判断两个立方体是否相等。
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;
class cube {
public:
void setc(int c) {
m_c = c;
}
void setk(int k) {
m_k = k;
}
void seth(int h) {
m_h = h;
}
int getc() {
return m_c;
}
int getk() {
return m_k;
}
int geth() {
return m_h;
}
int showV() {
return m_c * m_k * m_h;
}
int showS() {
return 2 * m_c * m_k + 2 * m_c * m_h + 2 * m_k * m_h;
}
bool chengyuan_issame(cube& c) {
if (m_c == c.getc() && m_k == c.getk() && m_h == c.geth()) {
return true;
}
return false;
}
private:
int m_c;
int m_k;
int m_h;
};
bool issame(cube &c1, cube &c2) {
if (c1.getc() == c2.getc() && c1.getk() == c2.getk() && c1.geth() == c2.geth()) {
return true;
}
return false;
}
int main() {
cube c1;
c1.setc(10);
c1.setk(10);
c1.seth(10);
cout << c1.showV() << endl;
cout << c1.showS() << endl;
cube c2;
c2.setc(10);
c2.setk(10);
c2.seth(10);
bool ret = issame(c1, c2);
if (ret == true) {
cout << "两个立方体相等" << endl;
}
else {
cout << "两个立方体不相等" << endl;
}
bool ret2 = c1.chengyuan_issame(c2);
if (ret2 == true) {
cout << "成员函数判断两个立方体相等" << endl;
}
else {
cout << "成员函数判断两个立方体不相等" << endl;
}
system("pause");
return 0;
}
练习案例
2
:点和圆的关系
设计一个圆形类(
Circle
),和一个点类(
Point
),计算点和圆的关系。
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;
//点
class point {
public:
//设置点的坐标
void setx(int x) {
m_x = x;
}
void sety(int y) {
m_y = y;
}
//获取点的坐标
int getx() {
return m_x;
}
int gety() {
return m_y;
}
private:
int m_x;
int m_y;
};
//圆
class circle {
public:
//设置圆的信息
void setr(int r) {
m_r = r;
}
void setcenter(point center) {
m_center = center;
}
//获取圆的信息
int getr() {
return m_r;
}
point getcenter() {
return m_center;
}
private:
int m_r;
point m_center;
};
//判断点是否在圆内
void isincircle(circle& c, point& p) {
//点到圆心距离的平方
int distance = (c.getcenter().getx() - p.getx()) * (c.getcenter().getx() - p.getx()) +
(c.getcenter().gety() - p.gety()) * (c.getcenter().gety() - p.gety());
//半径的平方
int ret = c.getr() * c.getr();
if (distance == ret) {
cout << "点在圆上" << endl;
}
else if (distance > ret) {
cout << "点在圆外" << endl;
}
else{
cout << "点在圆内" << endl;
}
}
int main() {
//点
point p;
p.setx(2);
p.sety(2);
//圆
circle c;
c.setr(2);
point center;//圆心
center.setx(0);
center.sety(0);
c.setcenter(center);
//判断点是否在圆内
isincircle(c, p);
system("pause");
return 0;
}
4.2对象的初始化和清理
4.2.1 构造函数和析构函数
对象的
初始化和清理
也是两个非常重要的安全问题
一个对象或者变量没有初始状态,对其使用后果是未知
同样的使用完一个对象或变量,没有及时清理,也会造成一定的安全问题
c++
利用了
构造函数
和
析构函数
解决上述问题,这两个函数将会被编译器自动调用,完成对象初始化和
清理工作。
对象的初始化和清理工作是编译器强制要我们做的事情,因此如果
我们不提供构造和析构,编译器会提
供
编译器提供的构造函数和析构函数是空实现。
构造函数:主要作用在于创建对象时为对象的成员属性赋值,构造函数由编译器自动调用,无须手
动调用。
析构函数:主要作用在于对象
销毁前
系统自动调用,执行一些清理工作。
构造函数语法:
类名
(){}
1.
构造函数,没有返回值也不写
void
2.
函数名称与类名相同
3.
构造函数可以有参数,因此可以发生重载
4.
程序在调用对象时候会自动调用构造,无须手动调用
,
而且只会调用一次
析构函数语法:
~
类名
(){}
1.
析构函数,没有返回值也不写
void
2.
函数名称与类名相同
,
在名称前加上符号
~
3.
析构函数不可以有参数,因此不可以发生重载
4.
程序在对象销毁前会自动调用析构,无须手动调用
,
而且只会调用一次
4.2.2 构造函数的分类及调用
两种分类方式:
按参数分为: 有参构造和无参构造
按类型分为: 普通构造和拷贝构造
三种调用方式:
括号法
显示法
隐式转换法
//1、构造函数分类
// 按照参数分类分为 有参和无参构造 无参又称为默认构造函数
// 按照类型分类分为 普通构造和拷贝构造
class Person {
public:
//无参(默认)构造函数
Person() {
cout << "无参构造函数!" << endl;
}
//有参构造函数
Person(int a) {
age = a;
cout << "有参构造函数!" << endl;
}
//拷贝构造函数
Person(const Person& p) {
age = p.age;
cout << "拷贝构造函数!" << endl;
}
//析构函数
~Person() {
cout << "析构函数!" << endl;
}
public:
int age;
};
//2、构造函数的调用
//调用无参构造函数
void test01() {
Person p; //调用无参构造函数
}
//调用有参的构造函数
void test02() {
//2.1 括号法,常用
Person p1(10);
//注意1:调用无参构造函数不能加括号,如果加了编译器认为这是一个函数声明
//Person p2();
//2.2 显式法
Person p2 = Person(10);
Person p3 = Person(p2);
//Person(10)单独写就是匿名对象 当前行结束之后,马上析构
//2.3 隐式转换法
Person p4 = 10; // Person p4 = Person(10);
Person p5 = p4; // Person p5 = Person(p4);
//注意2:不能利用 拷贝构造函数 初始化匿名对象 编译器认为是对象声明
//Person p5(p4);
}
int main() {
test01();
//test02();
system("pause");
return 0;
}
4.2.3 拷贝构造函数调用时机
C++
中拷贝构造函数调用时机通常有三种情况
使用一个已经创建完毕的对象来初始化一个新对象
值传递的方式给函数参数传值
以值方式返回局部对象
4.2.4 构造函数调用规则
默认情况下,
c++
编译器至少给一个类添加
3
个函数
1
.默认构造函数
(
无参,函数体为空
)
2
.默认析构函数
(
无参,函数体为空
)
3
.默认拷贝构造函数,对属性进行值拷贝
构造函数调用规则如下:
如果用户定义有参构造函数,
c++
不在提供默认无参构造,但是会提供默认拷贝构造
如果用户定义拷贝构造函数,
c++
不会再提供其他构造函数
4.2.5 深拷贝与浅拷贝
深浅拷贝是面试经典问题,也是常见的一个坑
浅拷贝:简单的赋值拷贝操作
深拷贝:在堆区重新申请空间,进行拷贝操作
如果属性有在堆区开辟的,一定要自己提供拷贝构造函数,防止浅拷贝带来的问题
class Person {
public:
//无参(默认)构造函数
Person() {
cout << "无参构造函数!" << endl;
}
//有参构造函数
Person(int age ,int height) {
cout << "有参构造函数!" << endl;
m_age = age;
m_height = new int(height);
}
//拷贝构造函数
Person(const Person& p) {
cout << "拷贝构造函数!" << endl;
//如果不利用深拷贝在堆区创建新内存,会导致浅拷贝带来的重复释放堆区问题
m_age = p.m_age;
m_height = new int(*p.m_height);
}
//析构函数
~Person() {
cout << "析构函数!" << endl;
if (m_height != NULL)
{
delete m_height;
}
}
public:
int m_age;
int* m_height;
};
void test01()
{
Person p1(18, 180);
Person p2(p1);
cout << "p1的年龄: " << p1.m_age << " 身高: " << *p1.m_height << endl;
cout << "p2的年龄: " << p2.m_age << " 身高: " << *p2.m_height << endl;
}
int main() {
test01();
system("pause");
return 0;
}
4.2.6 初始化列表
作用:
C++
提供了初始化列表语法,用来初始化属性
语法: 构造函数():属性1(值1),属性2(值2)... {}
4.2.7 类对象作为类成员
当类中成员是其他类对象时,我们称该成员为 对象成员构造的顺序是 :先调用对象成员的构造,再调用本类构造析构顺序与构造相反
4.2.8 静态成员
静态成员就是在成员变量和成员函数前加上关键字
static
,称为静态成员
静态成员分为:
静态成员变量所有对象共享同一份数据在编译阶段分配内存类内声明,类外初始化
静态成员函数所有对象共享同一个函数静态成员函数只能访问静态成员变量
class Person
{
public:
static int m_A; //静态成员变量
//静态成员变量特点:
//1 在编译阶段分配内存
//2 类内声明,类外初始化
//3 所有对象共享同一份数据
private:
static int m_B; //静态成员变量也是有访问权限的
};
int Person::m_A = 10;
int Person::m_B = 10;
void test01()
{
//静态成员变量两种访问方式
//1、通过对象
Person p1;
p1.m_A = 100;
cout << "p1.m_A = " << p1.m_A << endl;
Person p2;
p2.m_A = 200;
cout << "p1.m_A = " << p1.m_A << endl; //共享同一份数据
cout << "p2.m_A = " << p2.m_A << endl;
//2、通过类名
cout << "m_A = " << Person::m_A << endl;
//cout << "m_B = " << Person::m_B << endl; //私有权限访问不到
}
int main() {
test01();
system("pause");
return 0;
}
class Person
{
public:
//静态成员函数特点:
//1 程序共享一个函数
//2 静态成员函数只能访问静态成员变量
static void func()
{
cout << "func调用" << endl;
m_A = 100;
//m_B = 100; //错误,不可以访问非静态成员变量
}
static int m_A; //静态成员变量
int m_B; //
private:
//静态成员函数也是有访问权限的
static void func2()
{
cout << "func2调用" << endl;
}
};
int Person::m_A = 10;
void test01()
{
//静态成员变量两种访问方式
//1、通过对象
Person p1;
p1.func();
//2、通过类名
Person::func();
//Person::func2(); //私有权限访问不到
}
int main() {
test01();
system("pause");
return 0;
}
4.3 C++对象模型和this指针
4.3.1 成员变量和成员函数分开存储
在C++中,类内的成员变量和成员函数分开存储
只有非静态成员变量才属于类的对象上
class Person {
public:
Person() {
mA = 0;
}
//非静态成员变量占对象空间
int mA;
//静态成员变量不占对象空间
static int mB;
//函数也不占对象空间,所有函数共享一个函数实例
void func() {
cout << "mA:" << this->mA << endl;
}
//静态成员函数也不占对象空间
static void sfunc() {
}
};
int main() {
cout << sizeof(Person) << endl;
system("pause");
return 0;
}
4.3.2 this指针概念
通过
4.3.1
我们知道在
C++
中成员变量和成员函数是分开存储的
每一个非静态成员函数只会诞生一份函数实例,也就是说多个同类型的对象会共用一块代码
那么问题是:这一块代码是如何区分那个对象调用自己的呢?
c++
通过提供特殊的对象指针,
this
指针,解决上述问题。
this
指针指向被调用的成员函数所属的对象
this
指针是隐含每一个非静态成员函数内的一种指针
this
指针不需要定义,直接使用即可
this
指针的用途:
当形参和成员变量同名时,可用
this
指针来区分
在类的非静态成员函数中返回对象本身,可使用
return *this
class Person
{
public:
Person(int age)
{
//1、当形参和成员变量同名时,可用this指针来区分
this->age = age;
}
Person& PersonAddPerson(Person p)
{
this->age += p.age;
//返回对象本身
return *this;
}
int age;
};
void test01()
{
Person p1(10);
cout << "p1.age = " << p1.age << endl;
Person p2(10);
p2.PersonAddPerson(p1).PersonAddPerson(p1).PersonAddPerson(p1);
cout << "p2.age = " << p2.age << endl;
}
int main() {
test01();
system("pause");
return 0;
}
4.3.3 空指针访问成员函数
C++
中空指针也是可以调用成员函数的,但是也要注意有没有用到
this
指针
如果用到
this
指针,需要加以判断保证代码的健壮性
4.3.4 const修饰成员函数
常函数:
成员函数后加
const
后我们称为这个函数为
常函数
常函数内不可以修改成员属性
成员属性声明时加关键字
mutable
后,在常函数中依然可以修改
常对象:
声明对象前加
const
称该对象为常对象
常对象只能调用常函数
4.4 友元
友元的目的就是让一个函数或者类 访问另一个类中私有成员友元的关键字为 ==friend==友元的三种实现:1.全局函数做友元2.类做友元3.成员函数做友元
4.5 继承
继承的好处:== 可以减少重复的代码 ==class A : public B;A 类称为子类 或 派生类B 类称为父类 或 基类派生类中的成员,包含两大部分 :一类是从基类继承过来的,一类是自己增加的成员。从基类继承过过来的表现其共性,而新增的成员体现了其个性。继承的语法: class 子类 : 继承方式 父类继承方式一共有三种:公共继承保护继承私有继承/ 私有成员只是被隐藏了,但是还是会继承下去继承中 先调用父类构造函数,再调用子类构造函数,析构顺序与构造相反继承同名成员处理方式问题:当子类与父类出现同名的成员,如何通过子类对象,访问到子类或父类中同名的数据呢?访问子类同名成员 直接访问即可访问父类同名成员 需要加作用域继承同名静态成员处理方式问题:继承中同名的静态成员在子类对象上如何进行访问?静态成员和非静态成员出现同名,处理方式一致访问子类同名成员 直接访问即可访问父类同名成员 需要加作用域多继承语法C++ 允许 一个类继承多个类语法: class 子类 :继承方式 父类 1 , 继承方式 父类 2...多继承可能会引发父类中有同名成员出现,需要加作用域区分C++ 实际开发中不建议用多继承
![](https://i-blog.csdnimg.cn/blog_migrate/abe52b050050519725849ebabde16b08.png)
菱形继承菱形继承概念:两个派生类继承同一个基类又有某个类同时继承者两个派生类这种继承被称为菱形继承,或者钻石继承总结:菱形继承带来的主要问题是子类继承两份相同的数据,导致资源浪费以及毫无意义利用虚继承可以解决菱形继承问题
4.6多态
多态是 C++ 面向对象三大特性之一多态分为两类静态多态 : 函数重载 和 运算符重载属于静态多态,复用函数名动态多态 : 派生类和虚函数实现运行时多态静态多态和动态多态区别:静态多态的函数地址早绑定 - 编译阶段确定函数地址动态多态的函数地址晚绑定 - 运行阶段确定函数地址
多态满足条件有继承关系子类重写父类中的虚函数多态使用条件父类指针或引用指向子类对象重写:函数返回值类型 函数名 参数列表 完全一致称为重写
多态案例一
-
计算器类
案例描述:
利用多态技术,设计实现两个操作数进行运算的计算器类
#include <iostream>
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;
}
};
//除法计算器
class DivCalculator :public AbstractCalculator {
public:
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;//销毁创建的空间
//创建减法计算器
abc = new SubCalculator;
abc->m_num1 = 10;
abc->m_num2 = 10;
cout << abc->m_num1 << " - " << abc->m_num2 << " = " << abc->getResult() <<endl;
delete abc;
//创建乘法计算器
abc = new MulCalculator;
abc->m_num1 = 10;
abc->m_num2 = 10;
cout << abc->m_num1 << " * " << abc->m_num2 << " = " << abc->getResult() << endl;
delete abc;
//创建除法计算器
abc = new DivCalculator;
abc->m_num1 = 10;
abc->m_num2 = 10;
cout << abc->m_num1 << " / " << abc->m_num2 << " = " << abc->getResult() << endl;
delete abc;
}
int main() {
test01();
system("pause");
return 0;
}
在多态中,通常父类中虚函数的实现是毫无意义的,主要都是调用子类重写的内容因此可以将虚函数改为 纯虚函数纯虚函数语法: virtual 返回值类型 函数名 (参数列表) = 0 ;当类中有了纯虚函数,这个类也称为 == 抽象类 ==抽象类特点 :无法实例化对象子类必须重写抽象类中的纯虚函数,否则也属于抽象类
多态案例二
-
制作饮品
案例描述:
制作饮品的大致流程为:煮水
-
冲泡
-
倒入杯中
-
加入辅料
利用多态技术实现本案例,提供抽象制作饮品基类,提供子类制作咖啡和茶叶
#include <iostream>
using namespace std;
//抽象制作饮品
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:
//烧水
void Boil() {
cout << "烧矿泉水" << endl;
}
//冲泡
void Brew() {
cout << "冲泡咖啡" << endl;
}
//倒入杯中
void PourInCup() {
cout << "将咖啡倒入杯中" << endl;
}
//加入辅料
void PutSomething() {
cout << "加入糖和牛奶" << endl;
}
};
//制作茶水
class tea :public AbstractDrinking {
public:
//烧水
void Boil() {
cout << "烧自来水" << endl;
}
//冲泡
void Brew() {
cout << "冲泡茶叶" << endl;
}
//倒入杯中
void PourInCup() {
cout << "将茶水倒入杯中" << endl;
}
//加入辅料
void PutSomething() {
cout << "加入枸杞" << endl;
}
};
void DoWork(AbstractDrinking* drink) {
drink->MakeDrink();
delete drink;
}
void test01() {
DoWork(new coffee);
cout << "------------------------" << endl;
DoWork(new tea);
}
int main() {
test01();
system("pause");
return 0;
}
虚析构和纯虚析构多态使用时,如果子类中有属性开辟到堆区,那么父类指针在释放时无法调用到子类的析构代码解决方式:将父类中的析构函数改为 虚析构 或者 纯虚析构虚析构和纯虚析构共性:可以解决父类指针释放子类对象都需要有具体的函数实现虚析构和纯虚析构区别:如果是纯虚析构,该类属于抽象类,无法实例化对象
多态案例三
-
电脑组装
案例描述:
电脑主要组成部件为
CPU
(用于计算),显卡(用于显示),内存条(用于存储)
将每个零件封装出抽象基类,并且提供不同的厂商生产不同的零件,例如
Intel
厂商和
Lenovo
厂商
创建电脑类提供让电脑工作的函数,并且调用每个零件工作的接口
测试时组装三台不同的电脑进行工作
#include<iostream>
using namespace std;
//抽象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_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厂商
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* intelCpu = new IntelCPU;
VideoCard* intelCard = new IntelVideoCard;
Memory* intelMem = new IntelMemory;
cout << "第一台电脑开始工作:" << endl;
//创建第一台电脑
Computer* computer1 = new Computer(intelCpu, intelCard, intelMem);
computer1->work();
delete computer1;
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;
}
int main() {
test01();
system("pause");
return 0;
}