实验2：继承和多态

最新推荐文章于 2024-08-06 10:22:43 发布

JeffreyLiannnn

最新推荐文章于 2024-08-06 10:22:43 发布

阅读量276

点赞数 1

分类专栏： C++ 文章标签： c++ 开发语言后端

本文链接：https://blog.csdn.net/JeffreyLiannnn/article/details/121132608

版权

C++ 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

继承和多态

1.继承访问权限测试
2.友元类继承测试
- 友元函数分为三类（自主测试）
- 总结
3.多态性综合运用

1.继承访问权限测试

设计类A具有public, protected, private等不同属性的成员函数或变量

class A
{
public:
	//初始化
	A()
	{
		name = "lianjunwei";
		sex = 1;
		string phone = "123456789";
	}
//公共权限
public:
	string name;
//保护权限
protected:
	int sex;
//私有权限
private:
	string phone;
};

void test01()
{
	A testA;
	//name可以修改
	testA.name = "ljw";
	//sex不可以修改
	//testA.sex = 0;
	//phone不可以修改
	//testA.phone = "88888888";
	//name可以读取
	cout << testA.name << endl;
	//sex不可以读取
	//cout << testA.sex << endl;
	//phone不可以读取
	//cout << testA.phone << endl;
}

类B通过public, protected, private等不同方式继承A，在类B的成员函数中测试访问A的成员函数或变量

在这里插入图片描述

以public方式继承

class B1:public A
{
public:
	void func()
	{
		name = "ljw";//父类中的公共权限成员 到子类中依然是公共权限
		sex = 0;//父类中的保护权限成员 到子类中依然是保护权限
		//phone = "888888888"; //父类中的私有权限成员 子类访问不到
	}
};
void test02()
{
	B1 b1;
	cout << b1.name << endl;
	//cout << b1.sex << endl;//到B1中，sex是保护权限，类外访问不到
	//cout << b1.phone << endl;//到B1中，phone是私有权限，类外访问不到
}

以protected方式继承

class B2 :protected A
{
public:
	void func()
	{
		name = "ljw";//父类中的公共权限成员 到子类中变为保护权限
		sex = 0;//父类中的保护权限成员 到子类中依然是保护权限
		//phone = "888888888"; //父类中的私有权限成员 子类访问不到
	}
};
void test03()
{
	B2 b2;
	//cout << b2.name << endl;//到B2中，name是保护权限，类外访问不到
	//cout << b2.sex << endl;//到B2中，sex是保护权限，类外访问不到
	//cout << b2.phone << endl;//到B2中，phone是私有权限，类外访问不到
}

以private方式继承

class B3 :private A
{
public:
	void func()
	{
		name = "ljw";//父类中的公共权限成员 到子类中变为私有权限
		sex = 0;//父类中的保护权限成员 到子类中变为私有权限
		//phone = "888888888"; //父类中的私有权限成员 子类访问不到
	}
};
void test04()
{
	B3 b3;
	//cout << b3.name << endl;//到B3中，name是私有权限，类外访问不到
	//cout << b3.sex << endl;//到B3中，sex是私有权限，类外访问不到
	//cout << b3.phone << endl;//到B3中，phone是私有权限，类外访问不到
}

在类B中添加public, protected, private等不同属性的成员函数或变量，在外部测试访问B的各个成员函数或变量

在public中添加变量

class B1:public A
{
public:
	void func()
	{
		name = "ljw";//父类中的公共权限成员 到子类中依然是公共权限
		sex = 0;//父类中的保护权限成员 到子类中依然是保护权限
		//phone = "888888888"; //父类中的私有权限成员 子类访问不到
	}
//添加保护属性成员
protected:
	string email;
//添加私有属性成员
private:
	string address;
};
void test02()
{
	B1 b1;
	cout << b1.name << endl;
	//cout << b1.sex << endl;//到B1中，sex是保护权限，类外访问不到
	//cout << b1.phone << endl;//到B1中，phone是私有权限，类外访问不到
	//cout << b1.email << endl;//email是保护权限，类外访问不到
	//cout << b1.address << endl;//address是私有权限，类外访问不到
}

在protected中添加变量

class B2 :protected A
{
public:
	void func()
	{
		name = "ljw";//父类中的公共权限成员 到子类中变为保护权限
		sex = 0;//父类中的保护权限成员 到子类中依然是保护权限
		//phone = "888888888"; //父类中的私有权限成员 子类访问不到
	}
//添加保护属性成员
protected:
	string email;
//添加私有属性成员
private:
	string address;
};
void test03()
{
	B2 b2;
	//cout << b2.name << endl;//到B2中，name是保护权限，类外访问不到
	//cout << b2.sex << endl;//到B2中，sex是保护权限，类外访问不到
	//cout << b2.phone << endl;//到B2中，phone是私有权限，类外访问不到
	//cout << b1.email << endl;//email是保护权限，类外访问不到
	//cout << b1.address << endl;//address是私有权限，类外访问不到
}

在private中添加变量

class B3 :private A
{
public:
	void func()
	{
		name = "ljw";//父类中的公共权限成员 到子类中变为私有权限
		sex = 0;//父类中的保护权限成员 到子类中变为私有权限
		//phone = "888888888"; //父类中的私有权限成员 子类访问不到
	}
//添加保护属性成员
protected:
	string email;
//添加私有属性成员
private:
	string address;
};
void test04()
{
	B3 b3;
	//cout << b3.name << endl;//到B3中，name是私有权限，类外访问不到
	//cout << b3.sex << endl;//到B3中，sex是私有权限，类外访问不到
	//cout << b3.phone << endl;//到B3中，phone是私有权限，类外访问不到
}
	//cout << b1.email << endl;//email是保护权限，类外访问不到
	//cout << b1.address << endl;//address是私有权限，类外访问不到

总结

继承中构造和析构顺序：先构造父类，再构造子类，析构的顺序与构造的顺序相反
继承同名成员的处理方式：访问子类同名成员：直接访问即可；访问父类同名成员：需要加作用域 (s.Base::m_A)
多继承语法：语法：class 子类: 继承方式父类1, 继承方式父类2...

2.友元类继承测试

实验要求：

设计类A含有私有变量a，在类A中友元给类C；
设计类B继承A，添加私有变量b；在类C中测试访问类B的成员变量a, b;
设计类D继承C，在D的成员函数中测试访问类A的成员变量a，类B的成员变量a, b。

类A：

class A
{
	//友元类C给A
	friend class C;
public:
	A()//初始化A
	{
		a = 10;
	}
private:
	int a;
};

类B：

class B :public A
{
private:
	int b;
};

类C：

class C
{
public:
	//创建一个A类
	A testA;
	//测试友元
	void test();
};
//测试
void C::test()
{
	cout << "textA a = " << testA.a << endl;
	//B继承于A，但是B没有友元C，因此访问不到B的a
	//cout << "textB a = " << textB.a << endl;
	//b是B类的私有属性，C访问不到
	//cout << "textB b = " << textB.b << endl;
}

类D：

class D :public C
{
	A testA;
	B testB;
	void test();
};
//测试
void D::test()
{
	//D虽然继承于C，但是无法访问A中的a
	//cout << "testA a = " << textA.a << endl;
	//无法访问B中的a
	//cout << "textB a = " << textB.a << endl;
	//b是B类的私有属性，D访问不到
	//cout << "textB b = " << textB.b << endl;
}

友元函数分为三类（自主测试）

全局函数做友元

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

class Building
{
	friend void goodGay(Building* building);
public:
	Building()
	{
		SittingRoom = "客厅";
		BedRoom = "卧室";
	}
private:
	string BedRoom;
public:
	string SittingRoom;
};

void goodGay(Building* building)
{
	cout << "正在访问： " << building->SittingRoom << endl;
	cout << "正在访问： " << building->BedRoom << endl;
}

void test01()
{
	Building b1;
	goodGay(&b1);
}

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

类做友元

class Building
{
	//告诉编译器 goodGay类是Building类的好朋友，可以访问到Building类中的私有内容
	friend class goodGay;
}

成员函数做友元

class Building
{
	//告诉编译器，GoodGay类下的visit成员函数可以访问私有内容
	friend void GoodGay::visit();
}

总结

public：基类的public和protected成员：访问属性在派生类中保持不变；基类的private成员：不可直接访问。
protected：基类的public和protected成员：都以protected身份出现在派生类中；基类的private成员：不可直接访问。
privated：基类的public和protected成员，都以private身份出现在派生类中；基类的private成员：不可直接访问。

3.多态性综合运用

基本概念

多态分为两类

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

静态多态和动态多态的区别

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

class Animal
{
public:
	//speak函数是虚函数
	//函数前面加上virtual关键字，变成虚函数，那么编译器在编译的时候就不能确定函数调用了
	virtual void speak()
	{
		cout<<"Animal is speaking"<<endl;
	}
};

class Cat:public Animal
{
public:
	void speak()
	{
		cout<<"miao miao miao"<<endl;
	}
};

class Dog:public Animal
{
public:
	void speak()
	{
		cout<<"wang wang wang"<<endl;
	}
};

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

void test01()
{
	Cat cat;
	DoSpeak(cat);
	Dog dog;
	DoSpeak(dog);
}

多态满足的条件

有继承关系
子类重写父类中的虚函数
函数返回值类型函数名参数列表完全一致称为重写

编写了一个计算器的案例，对比普通写法和多态实现的区别

普通写法

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

class Calculator
{
public:
	int GetResult(string oper)
	{
		if(oper == "+")
			return m_Num1+m_Num2;
		if(oper == "-")
			return m_Num1-m_Num2;
		if(oper == "*")
			return m_Num1*m_Num2;
	}
	int m_Num1;
	int m_Num2;
};

int main()
{
	Calculator c;
	c.m_Num1=10;
	c.m_Num2=10;
	cout<<c.m_Num1<<"+"<<c.m_Num2<<c.GetResult("+")<<endl;
}

利用多态实现

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 test()
{
	AbstractCalculator* abc = new AddCalculator;
	abc->m_Num1 = 10;
	abc->m_Num2 = 10;
	cout<<abc->getResult()<<endl;
	delete abc;
	abc = new SubCalculator;
	abc->m_Num1 = 100;
	abc->m_Num2 = 100;
	cout<<abc->getResult()<<endl;
	delete abc;
	abc = new MulCalculator;
	abc->m_Num1 = 100;
	abc->m_Num2 = 100;
	cout<<abc->getResult()<<endl;
	delete abc;
}

void mian()
{
	test();
}

纯虚函数

在多态中，通常父类中虚函数的实现是没有意义的，主要都是调用子类重写的内容
因此可以将虚函数改为纯虚函数
纯虚函数语法：virtual 返回值类型函数名(参数列表) = 0
当类中有纯虚函数，类就变成抽象类

抽象类特点

无法实例化对象
抽象类的字类必须要重写父类中的纯虚函数，否则也属于抽象类

JeffreyLiannnn

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
实验2：继承和多态

继承和多态1.继承访问权限测试设计类A具有public, protected, private等不同属性的成员函数或变量类B通过public, protected, private等不同方式继承A，在类B的成员函数中测试访问A的成员函数或变量以public方式继承以protected方式继承以private方式继承在类B中添加public, protected, private等不同属性的成员函数或变量，在外部测试访问B的各个成员函数或变量在public中添加变量在protected中添加变量在privat
复制链接

扫一扫

专栏目录