C++学习记录 实验2 继承和多态

最新推荐文章于 2024-06-26 20:17:52 发布
最新推荐文章于 2024-06-26 20:17:52 发布
阅读量127 收藏
点赞数
分类专栏： C++学习笔记 文章标签： c++ 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lim11t/article/details/120785502
版权

目录

一、继承访问权限测试

1.1 源码实现

#include<istream>
using namespace std;
class A {
public:
	int _a;
protected:
	int _b;
private:
	int _c;
};
class Pub_B :public A {
public:
	void Test() {
		_a = 10;
		_b = 10;
		//_c = 10;不可访问
	}
	int pub_pub_b1;
protected:
	int pub_pro_b2;
private:
	int pub_pri_b3;
};
class Pro_B :protected A {
public:
	void Test() {
		_a = 10;
		_b = 10;
		//_c = 10;不可访问
	}
	int pro_pub_b1;
protected:
	int pro_pro_b2;
private:
	int pro_pri_b3;
};
class Pri_B :private A {
public:
	void Test() {
		_a = 10;
		_b = 10;
		//_c = 10;不可访问
	}
	int pri_pub_b1;
protected:
	int pri_pro_b2;
private:
	int pri_pri_b3;
};
class newPri_B :private A {
public:
	void Test() {
		_a = 10;
		_b = 10;
		//_c = 10;不可访问
	}
	int pri_pub_b1;
	using A::_a;
protected:
	int pri_pro_b2;
private:
	int pri_pri_b3;
};

B以private方式继承A，使用{using A::_a; }把A中的部分public成员提升为了public，接着进行访问测试：

void test()
{
	A a;
	a._a;
	//a._b;
	//a._c;
	Pub_B s1;
	s1.pub_pub_b1;
	s1._a;
	//s1._b;
	//si._c;
	//s1.pub_pro_b2;不可访问
	//s1.pub_pri_b3;不可访问
	Pro_B s2;
	s2.pro_pub_b1;
	//s2._a;s2._b;s2._c;
	//s2.pro_pro_b2;不可访问
	//s2.pro_pri_b3;不可访问
	Pri_B s3;
	s3.pri_pub_b1;
	//s3._a;s3._b;s3._c;
	//s3.pri_pro_b2;不可访问
	//s3.pri_pri_b3;不可访问
	newPri_B s4;
	s4.pri_pub_b1;
	//s4.pri_pro_b2;
	s4._a;
	//s4._b;
}

测试结果如图所示：
在这里插入图片描述

在这里插入图片描述
如果想让这些继承而来的数据成员作为public或者protected成员，可以用using重新声明。using声明语句中名字的访问权限由该using声明语句之前的访问说明符决定。

二、友元类继承测试

2.1 源码实现

#include<istream>
using namespace std;
//声明C为A的友元类
class A {
private:
	int _a;
	friend class C;
};
class B: public A {
private:
	int b;
};
class C {
public:
	void Test() {
		B b1;
		b1._a;
		//b1._b;
	}
};
class D :public C {
public:
	void Test() {
		A a1;
		//a1._a;
		B b2;
		//b2._a;
		//b2._b;
	}
};

测试结果如图所示：
在这里插入图片描述
在这里插入图片描述

  • 设计类A含有私有变量a，在类A中友元给类C；设计类B继承A，添加私有变量b；在类C中测试访问类B的成员变量a, b;此时类C中访问不到类B的私有成员量b，但是访问得到成员量a。
  • 设计类D继承C，在D的成员函数中测试访问类A的成员变量a，类B的成员变量a, b。对于类D来说，A的成员变量a，类B的成员变量a, b均不可见。
  • 当类Y被说明为类X的友元时，类Y的所有成员函数都成为类X的友元函数，这就意味着作为友元类Y中的所有成员函数都可以访问类X中的所有成员（包括私有成员）。
  • 友元关系是单向的，不具有交换性。友元关系也不具有传递性。友元关系不能被继承，基类的友元类未必是子类的友元，某类型的友元的子类未必是该类型的友元。

三、多态性综合运用

3.1 实验内容

设计矢量图，运用多继承设计组合图形，要求具备创建不同类型矢量图、选择图形、移动图形、用不同颜色显示图形（表示选中与否），用vector或数组管理图形。

3.2 源码实现

3.2.1 CShape.h

#pragma once
#ifndef CSHAPE_H
#define CSHAPE_H
#include<string>
#include<math.h>
using namespace std;

class CPoint;
class CRect;
class CShape
{
public:
	CShape();
	CShape(const CShape& shape);
	virtual ~CShape();
	virtual double GetArea() const;
	virtual bool ptIn(const CPoint& pt) const;
	virtual bool InRect(const CRect& rc) const;
	virtual void Draw() const;
	virtual void DrawColor();
	virtual CShape* Clone() const;
	virtual CShape& Move(int nOffsetX, int nOffsetY);

以上这些被virtual关键字修饰的成员函数，就是虚函数。虚函数的作用，就是在实现多态性，而多态性是将接口与实现进行分离，所以也可以称为一般多态性函数；用形象的语言来解释就是实现以共同的方法，但因个体差异而采用不同的策略。

protected:
	string m_sName;
};

class CPoint :public CShape {
public:
	int m_nPosX;
	int m_nPosY;
	CPoint() {
		m_nPosX = 0;
		m_nPosY = 0;
	}
	CPoint(int nPosX, int nPosY);
	CPoint(const CPoint& pt);
	virtual ~CPoint();
	double GetArea() const;
	bool ptIn(const CPoint& pt) const;
	bool InRect(const CRect& rc) const;
	void Draw() const;
	void DrawColor();
	CPoint* Clone() const;
	CPoint& Move(int nOffsetX, int nOffsetY);
};
class CTriangle :virtual public CShape {
public:
	CTriangle() {}
	CTriangle(const CPoint& pt1, const CPoint& pt2, const CPoint& pt3);
	CTriangle(const CTriangle& rc);
	CTriangle(const CPoint& pt);
	virtual ~CTriangle();
	double GetArea() const;
	bool ptIn(const CPoint& pt) const;
	bool InRect(const CRect& rc) const;
	void Draw() const;
	void DrawColor();
	CShape* Clone() const;
	CShape& Move(int nOffsetX, int nOffsetY);
	CPoint m_pts[3];
};

class CRect :virtual public CShape {
public:
	CRect() {}
	CRect(CPoint pt1, CPoint pt2);
	CRect(const CRect& rc);
	CRect(CPoint pt1);
	virtual ~CRect();
	double GetArea() const;
	bool ptIn(const CPoint& pt) const;
	bool InRect(const CRect& rc) const;
	void Draw() const;
	void DrawColor();
	CShape* Clone() const;
	CShape& Move(int nOffsetX, int nOffsetY);
	CPoint m_ptLT;
	CPoint m_ptBR;
};

class Comgraphics :public CRect, public CTriangle {
public:
	Comgraphics(const CRect& pt1);
	Comgraphics(const Comgraphics& rc);
	Comgraphics(const CPoint pt1);
	virtual ~Comgraphics();
	double GetArea() const;
	bool ptIn(const CPoint& pt) const;
	bool InRect(const CRect& rc) const;
	void Draw() const;
	void DrawColor();
	CShape* Clone() const;
	CShape& Move(int nOffsetX, int nOffsetY);
	CPoint m_pt1;
	CPoint m_pt2;

};
#endif

只需把基类的成员函数设为virtual，其派生类的相应的函数也会自动变为虚函数。再对虚函数做一个总结就是：指向基类的指针在操作它的多态类对象时，会根据不同的类对象，调用其相应的函数，这个函数就是虚函数 。

3.2.2 CShape.cpp

#include "CShape.h"
#include "graphics.h"
#include <iostream>
using namespace std;
//CShape
CShape::CShape()
{
}
CShape::CShape(const CShape& shape) {
	m_sName = shape.m_sName;
}
CShape::~CShape()
{
}
double CShape::GetArea() const {
	return 0;
}
bool CShape::ptIn(const CPoint& pt) const {
	return false;
}
bool CShape::InRect(const CRect& rc) const {
	return false;
}
void CShape::Draw() const
{
}
void CShape::DrawColor()
{
}
CShape* CShape::Clone() const {
	return new CShape(*this);
}
CShape& CShape::Move(int nOffsetX, int nOffsetY) {
	return *this;
}

//CPoint
CPoint::CPoint(int nPosX, int nPosY) {
	m_nPosX = nPosX;
	m_nPosY = nPosY;
}
CPoint::CPoint(const CPoint& pt) {
	m_nPosX = pt.m_nPosX;
	m_nPosY = pt.m_nPosY;
}
CPoint::~CPoint() {
	//cout << "CPoint::~CPoint()\n";
}
double CPoint::GetArea() const {
	return 0;
}
bool CPoint::ptIn(const CPoint& pt) const {
	return false;
}
bool CPoint::InRect(const CRect& rc) const {
	return rc.ptIn(*this);
}
void CPoint::Draw() const {
	circle(m_nPosX, m_nPosY, 2);
}
void CPoint::DrawColor()
{
}
CPoint* CPoint::Clone() const {
	return new CPoint(*this);
}
CPoint& CPoint::Move(int nOffsetX, int nOffsetY) {
	m_nPosX += nOffsetX;
	m_nPosY += nOffsetY;
	return *this;
}

//CTriangle
CTriangle::CTriangle(const CTriangle& tri) {
	for (int i = 0; i < 3; i++) {
		m_pts[i] = tri.m_pts[i];
	}
}
CTriangle::~CTriangle() {
	//cout << "CTriangle::~CTriangle()\n";
}
CTriangle::CTriangle(const CPoint& pt1, const CPoint& pt2, const CPoint& pt3) {
	m_pts[0] = pt1;
	m_pts[1] = pt2;
	m_pts[2] = pt3;
}
CTriangle::CTriangle(const CPoint& pt)
{
	CPoint* pt1 = new CPoint(pt.m_nPosX + 100, pt.m_nPosY + 90);
	CPoint* pt2 = new CPoint(pt.m_nPosX, pt.m_nPosY + 90);
	m_pts[0] = pt;
	m_pts[1] = *pt1;
	m_pts[2] = *pt2;
}

CShape& CTriangle::Move(int nOffsetX, int nOffsetY) {
	for (int i = 0; i < 3; i++) {
		m_pts[i].Move(nOffsetX, nOffsetY);
	}
	return *this;
}
double CTriangle::GetArea() const {
	int x1, y1, x2, y2, x3, y3;
	x1 = m_pts[0].m_nPosX;
	y1 = m_pts[0].m_nPosY;
	x2 = m_pts[1].m_nPosX;
	y2 = m_pts[1].m_nPosY;
	x3 = m_pts[2].m_nPosX;
	y3 = m_pts[2].m_nPosY;

	double bottomLine = sqrt(pow(x1 - x2, 2) + pow(y1 - y2, 2));
	double verticalLine1 = abs((y1 - y2) * x3 - (x1 - x2) * y3 + (x1 - x2) * y2 - (y1 - y2) * x2);
	double verticalLine2 = sqrt(pow(y1 - y2, 2) + pow(x1 - x2, 2));
	double verticalLine = verticalLine1 / verticalLine2;

	return (verticalLine * bottomLine) / 2.0;
}
bool CTriangle::ptIn(const CPoint& pt) const {
	CTriangle c1 = CTriangle(m_pts[0], m_pts[1], pt);
	CTriangle c2 = CTriangle(m_pts[1], m_pts[2], pt);
	CTriangle c3 = CTriangle(m_pts[2], m_pts[0], pt);

	double totalArea = c1.GetArea() + c2.GetArea() + c3.GetArea();

	if (totalArea == this->GetArea())
		return true;
	else
		return false;
}
bool CTriangle::InRect(const CRect& rc) const {
	return rc.ptIn(m_pts[0]) && rc.ptIn(m_pts[1]) && rc.ptIn(m_pts[2]);
}
void CTriangle::Draw() const {
	int poly[8] = { m_pts[0].m_nPosX ,m_pts[0].m_nPosY,m_pts[1].m_nPosX,m_pts[1].m_nPosY,
				m_pts[2].m_nPosX,m_pts[2].m_nPosY, m_pts[0].m_nPosX ,m_pts[0].m_nPosY };
	setfillcolor(EGERGB(0xFF, 0xFF, 0xFF));
	fillpoly(4, poly);
}
void CTriangle::DrawColor() {
	int poly[8] = { m_pts[0].m_nPosX ,m_pts[0].m_nPosY,m_pts[1].m_nPosX,m_pts[1].m_nPosY,
				m_pts[2].m_nPosX,m_pts[2].m_nPosY, m_pts[0].m_nPosX ,m_pts[0].m_nPosY };
	setfillcolor(EGERGB(0xFF, 0xA5, 0x00));
	fillpoly(4, poly);
}
CShape* CTriangle::Clone() const {
	return new CTriangle(*this);
}

//CRect
CRect::CRect(CPoint pt1, CPoint pt2) {
	m_ptLT = CPoint(min(pt1.m_nPosX, pt2.m_nPosX), min(pt1.m_nPosY, pt2.m_nPosY));
	m_ptBR = CPoint(max(pt1.m_nPosX, pt2.m_nPosX), max(pt1.m_nPosY, pt2.m_nPosY));
}
CRect::CRect(const CRect& rc) {
	m_ptLT = rc.m_ptLT;
	m_ptBR = rc.m_ptBR;
}
CRect::CRect(CPoint pt1)
{
	m_ptLT = CPoint(pt1.m_nPosX, pt1.m_nPosY);
	m_ptBR = CPoint(pt1.m_nPosX + 100, pt1.m_nPosY + 100);
}
CRect::~CRect() {
	// cout << "CRect::CRect()\n";
}
double CRect::GetArea() const {
	return (m_ptBR.m_nPosX - m_ptLT.m_nPosX) * (m_ptBR.m_nPosY - m_ptLT.m_nPosY);
}
bool CRect::ptIn(const CPoint& pt) const {
	return (pt.m_nPosX >= m_ptLT.m_nPosX && pt.m_nPosX <= m_ptBR.m_nPosX) &&
		(pt.m_nPosY >= m_ptLT.m_nPosY && pt.m_nPosY <= m_ptBR.m_nPosY);
}
bool CRect::InRect(const CRect& rc) const {
	return rc.ptIn(m_ptLT) && rc.ptIn(m_ptBR);
}
void CRect::Draw() const {
	// 存储n个顶点的x,y坐标
	int pts[10] = { m_ptLT.m_nPosX,m_ptLT.m_nPosY,m_ptBR.m_nPosX,m_ptLT.m_nPosY,
	m_ptBR.m_nPosX,m_ptBR.m_nPosY,m_ptLT.m_nPosX,m_ptBR.m_nPosY,m_ptLT.m_nPosX,m_ptLT.m_nPosY };
	// 绘制n个顶点的多边形，第一个参数必须要传入n+1，pts最后一个顶点坐标和第一个相同
	//drawpoly(5, pts);
	setfillcolor(EGERGB(0xFF, 0xFF, 0xFF));
	fillpoly(5, pts);
}
void CRect::DrawColor() {
	int pts[10] = { m_ptLT.m_nPosX,m_ptLT.m_nPosY,m_ptBR.m_nPosX,m_ptLT.m_nPosY,
	m_ptBR.m_nPosX,m_ptBR.m_nPosY,m_ptLT.m_nPosX,m_ptBR.m_nPosY,m_ptLT.m_nPosX,m_ptLT.m_nPosY };
	// 绘制n个顶点的多边形，第一个参数必须要传入n+1，pts最后一个顶点坐标和第一个相同
	setfillcolor(EGERGB(0xFF, 0xA5, 0x00));
	fillpoly(5, pts);
}
CShape* CRect::Clone() const {
	return new CRect(*this);
}
CShape& CRect::Move(int nOffsetX, int nOffsetY) {
	m_ptLT.Move(nOffsetX, nOffsetY);
	m_ptBR.Move(nOffsetX, nOffsetY);
	return *this;

}
//Comgraphics
Comgraphics::Comgraphics(const CRect& pt1) {

	m_pt1.m_nPosX = pt1.m_ptBR.m_nPosX;
	m_pt1.m_nPosY = pt1.m_ptLT.m_nPosY + (pt1.m_ptBR.m_nPosY - pt1.m_ptLT.m_nPosY) / 2;
	m_pt2.m_nPosX = pt1.m_ptLT.m_nPosX + (pt1.m_ptBR.m_nPosX - pt1.m_ptLT.m_nPosX) / 2;
	m_pt2.m_nPosY = pt1.m_ptBR.m_nPosY;
	m_ptLT = pt1.m_ptLT;
	m_ptBR = pt1.m_ptBR;

}
Comgraphics::Comgraphics(const Comgraphics& rc) {
	m_pt1 = rc.m_pt1;
	m_pt2 = rc.m_pt2;
	m_ptBR = rc.m_ptBR;
	m_ptLT = rc.m_ptLT;
}
Comgraphics::Comgraphics(const CPoint pt1) {
	m_ptLT = CPoint(pt1.m_nPosX, pt1.m_nPosY);
	m_ptBR = CPoint(pt1.m_nPosX + 60, pt1.m_nPosY + 80);
}
Comgraphics::~Comgraphics() {
	cout << "Comgraphics::~Comgraphics()" << endl;

}
double Comgraphics::GetArea()  const {
	return 0.0;
}
bool Comgraphics::ptIn(const CPoint& pt) const {
	return (pt.m_nPosX >= m_ptLT.m_nPosX && pt.m_nPosX <= m_ptBR.m_nPosX) &&
		(pt.m_nPosY >= m_ptLT.m_nPosY && pt.m_nPosY <= m_ptBR.m_nPosY);
}
bool Comgraphics::InRect(const CRect& rc) const const {
	return rc.ptIn(m_ptLT) && rc.ptIn(m_ptBR);
}
void Comgraphics::Draw() const {
	// 存储n个顶点的x,y坐标
	int pts[10] = { m_ptLT.m_nPosX,m_ptLT.m_nPosY,m_ptBR.m_nPosX,m_ptLT.m_nPosY,
	m_ptBR.m_nPosX,m_ptBR.m_nPosY,m_ptLT.m_nPosX,m_ptBR.m_nPosY,m_ptLT.m_nPosX,m_ptLT.m_nPosY };
	// 绘制n个顶点的多边形，第一个参数必须要传入n+1，pts最后一个顶点坐标和第一个相同
	//drawpoly(5, pts);
	setfillcolor(GREEN);
	fillpoly(5, pts);
	line(m_pt1.m_nPosX, m_pt1.m_nPosY, m_pt2.m_nPosX, m_pt2.m_nPosY);
	line(m_ptLT.m_nPosX, m_ptLT.m_nPosY, m_pt2.m_nPosX, m_pt2.m_nPosY);
	line(m_pt1.m_nPosX, m_pt1.m_nPosY, m_ptLT.m_nPosX, m_ptLT.m_nPosY);
}
void Comgraphics::DrawColor() {
	// 存储n个顶点的x,y坐标
	int pts[10] = { m_ptLT.m_nPosX,m_ptLT.m_nPosY,m_ptBR.m_nPosX,m_ptLT.m_nPosY,
	m_ptBR.m_nPosX,m_ptBR.m_nPosY,m_ptLT.m_nPosX,m_ptBR.m_nPosY,m_ptLT.m_nPosX,m_ptLT.m_nPosY };
	// 绘制n个顶点的多边形，第一个参数必须要传入n+1，pts最后一个顶点坐标和第一个相同
	setfillcolor(YELLOW);
	fillpoly(5, pts);
	line(m_pt1.m_nPosX, m_pt1.m_nPosY, m_pt2.m_nPosX, m_pt2.m_nPosY);
	line(m_ptLT.m_nPosX, m_ptLT.m_nPosY, m_pt2.m_nPosX, m_pt2.m_nPosY);
	line(m_pt1.m_nPosX, m_pt1.m_nPosY, m_ptLT.m_nPosX, m_ptLT.m_nPosY);
}
CShape* Comgraphics::Clone() const {
	return new Comgraphics(*(this));
}

CShape& Comgraphics::Move(int nOffsetX, int nOffsetY) {
	m_ptLT.Move(nOffsetX, nOffsetY);
	m_ptBR.Move(nOffsetX, nOffsetY);
	m_pt1.Move(nOffsetX, nOffsetY);
	m_pt2.Move(nOffsetX, nOffsetY);
	return *this;
}

3.2.3 main.cpp

#include<vector>
#include "graphics.h"
#include<iostream>
#include "CShape.h"
using namespace std;

int main()
{
	//图形画布基础设置
	initgraph(640, 480);
	setbkcolor(WHITE);
	delay_ms(0);
	setcolor(BLACK);
	setfont(20, 0, "楷体");
	setbkmode(TRANSPARENT);
	//enter+左击-->新建矩形");
	//enter+右击-->新建三角形");
	//enter+滚轮中间-->新建组合图形

	//ctrl+左击-->复制图形");
	//ctrl+右击-->粘贴图形");

	vector<CShape*>shapes;
	vector<CShape*>shapestmp;

	shapes.push_back(new CTriangle(CPoint(320, 320), CPoint(250, 340), CPoint(340, 450)));
	//shapes.push_back(new CTriangle(CPoint(10, 10), CPoint(150, 10), CPoint(150, 150)));
	shapes.push_back(new CRect(CPoint(200, 200), CPoint(300, 300)));
	shapes.push_back(new Comgraphics(CRect(CPoint(250, 50))));


	//移动
	bool move_flag = false;
	bool copy_flag = false;
	bool redraw = true;
	//鼠标点击时记录它的坐标
	int clickX, clickY;
	int copyX, copyY;
	int checkedid = -1;
	int copyid = -1;

	for (; is_run(); delay_fps(60)) {
		while (mousemsg()) {
			mouse_msg msg = getmouse();

			//判断鼠标的移动
			if (msg.is_move()) {
				if (checkedid != -1) {
					if (move_flag) {
						shapes[checkedid]->Move(msg.x - clickX, msg.y - clickY);
					}
				}
				clickX = msg.x;
				clickY = msg.y;
				redraw = true;
			}

			// 判断鼠标左键
			else if (msg.is_left()) {
				// 判断鼠标左键是否按下
				if (msg.is_down()) {
					clickX = msg.x;
					clickY = msg.y;

					CPoint pt = CPoint(clickX, clickY);
					int isIn = 0;
					for (int i = 0; i < shapes.size(); i++) {
						if (shapes[i]->ptIn(pt)) {
							isIn = 1;
							//如果鼠标在图形区域内就设置移动的flag为true
							move_flag = true;
							checkedid = i;
							redraw = true;
							break;
						}
					}
					if (isIn == 0)
						checkedid = -1;
				}
				else {
					move_flag = false;
				}
			}
		}
		// 重新绘图
		if (redraw) {
			redraw = false;
			cleardevice();
			for (int i = 0; i < shapes.size(); i++) {
				if (i == checkedid)
					shapes[i]->DrawColor();
				else
					shapes[i]->Draw();
			}
		}

		while (kbmsg()) {
			key_msg msgk = getkey();
			if (msgk.key == key_enter && msgk.msg == key_msg_down) {
				mouse_msg msgm = getmouse();
				if (msgm.is_left()) {
					// 判断鼠标左键是否按下
					if (msgm.is_down()) {
						shapes.push_back(new CRect(CPoint(msgm.x, msgm.y)));
						redraw = true;
					}
				}
				if (msgm.is_right()) {
					// 判断鼠标右键是否按下
					if (msgm.is_down()) {
						shapes.push_back(new CTriangle(CPoint(msgm.x, msgm.y)));
						redraw = true;
					}
				}
				if (msgm.is_mid()) {
					CRect r1 = CRect(CPoint(msgm.x, msgm.y));
					// 判断鼠标中键是否按下
					if (msgm.is_down()) {
						shapes.push_back(new Comgraphics(r1));
						redraw = true;
					}
				}
			}
			if (msgk.key == key_control && msgk.msg == key_msg_down) {
				mouse_msg msgm = getmouse();
				if (msgm.is_left()) {
					// 判断鼠标左键是否按下
					if (msgm.is_down()) {
						copyX = msgm.x;
						copyY = msgm.y;
						CPoint pt = CPoint(copyX, copyY);
						for (int i = 0; i < shapes.size(); i++) {
							if (shapes[i]->ptIn(pt)) {
								//如果鼠标在图形区域内就设置移动的flag为true
								copy_flag = true;
								copyid = i;
								break;
							}
						}
					}
				}
				if (msgm.is_right()) {
					// 判断鼠标右键是否按下
					if (msgm.is_down()) {
						if (copy_flag == true) {
							shapes.push_back(&(shapes[copyid]->Clone())->Move(msgm.x - copyX, msgm.y - copyY));
							redraw = true;
						}
					}
				}

			}
		}
	}
	closegraph();
	return 0;
}

派生类有多个基类继承而来叫做多继承，其构造时按照基类在派生类中的声明顺序依次进行，由于派生类有多个基类派生而来，所以可能出现命名冲突，而当出现冲突时使用，需要指明到底使用的是哪个类的成员。

实验截图：
在这里插入图片描述
在这里插入图片描述

四、实验总结

4.1 继承访问权限

由三种访问权限和三种继承方式可以得到以下的九种组合结果：

基类中      继承方式             子类中

public     ＆ public继承        => public
public     ＆ protected继承     => protected  
public     ＆ private继承       => private

protected  ＆ public继承        => protected
protected  ＆ protected继承     => protected  
protected  ＆ private继承       => private

private    ＆ public继承        => 子类无权访问
private    ＆ protected继承     => 子类无权访问
private    ＆ private继承       => 子类无权访问

由以上组合结果可以看出

1、public继承不改变基类成员的访问权限
2、private继承使得基类所有成员在子类中的访问权限变为private
3、protected继承将基类中public成员变为子类的protected成员，其它成员的访问权限不变。
4、基类中的private成员不受继承方式的影响，子类永远无权访问。

4.2 友元类访问权限

  • 设计类A含有私有变量a，在类A中友元给类C；设计类B继承A，添加私有变量b；在类C中测试访问类B的成员变量a, b;此时类C中访问不到类B的私有成员量b，但是访问得到成员量a。
  • 设计类D继承C，在D的成员函数中测试访问类A的成员变量a，类B的成员变量a, b。对于类D来说，A的成员变量a，类B的成员变量a, b均不可见。
  • 当类Y被说明为类X的友元时，类Y的所有成员函数都成为类X的友元函数，这就意味着作为友元类Y中的所有成员函数都可以访问类X中的所有成员（包括私有成员）。
  • 友元关系是单向的，不具有交换性。友元关系也不具有传递性。友元关系不能被继承，基类的友元类未必是子类的友元，某类型的友元的子类未必是该类型的友元。

4.3 关于多态

到底什么是多态？
顾名思义就是同一个事物在不同场景下的多种形态。
函数的重载就是一种静态的多态。静态多态是编译器在编译期间完成的，编译器会根据实参类型来选择调用合适的函数，如果有合适的函数可以调用就调，没有的话就会发出警告或者报错。
动态的多态则是在程序运行时根据基类的引用（指针）指向的对象来确定自己具体该调用哪一个类的虚函数。

4.4 多继承与虚继承

多继承：派生类有多个基类继承而来叫做多继承，其构造时按照基类在派生类中的声明顺序依次进行，由于派生类有多个基类派生而来，所以可能出现命名冲突，而当出现冲突时使用，需要指明到底使用的是哪个类的成员。
在这里插入图片描述
c对象由A、B派生而来，内存模型如上图所示

虚继承：也称菱形继承，类 A 派生出类 B 和类 C，类 D 继承自类 B 和类 C，这个时候类 A 中的成员变量和成员函数继承到类 D 中变成了两份，一份来自 A–>B–>D 这条路径，另一份来自 A–>C–>D 这条路径。当需要访问A的成员变量时，就会产二义性。
那么如何解决这样的问题呢？此时就需要采用虚继承，在继承方式前面加上virtual，派生类中只保留一份间接类的成员。虚继承的类也叫做虚基类。也就是当出现这样的二义性问题时，我们需要使用虚继承。

虚继承时的构造函数：以上为例D的析构函数，不仅要调用BC的构造函数还有直接调用A的构造函数，虚继承时构造函数的执行顺序与普通继承时不同：在最终派生类的构造函数调用列表中，不管各个构造函数出现的顺序如何，编译器总是先调用虚基类的构造函数，再按照出现的顺序调用其他的构造函数；而对于普通继承，就是按照构造函数出现的顺序依次调用的。

coderJHT
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[C++学习实验2] 继承和多态
luckylcylzr的博客
11-02 269
一、继承访问权限测试 1、概述 C++面向对象的三大特性为：封装、继承、多态 （1）设计类Person具有public, protected, private等不同属性的成员函数或变量； （2）类Student，Teacher，worker通过public, protected, private等不同方式继承Person，在继承类的成员函数中测试访问父类Person的成员函数或变量； （3）在继承类中添加public, protected, private等不同属性的成员函数或变量，在外部测试访问继承
c++多态实验
12-13
C++的多态性是面向对象编程中的一个核心特性，它允许不同的对象对同一消息做出不同的响应。在C++中，多态主要通过虚函数（virtual functions）和纯虚函数...通过查看实验报告和代码，你可以深入学习多态在C++中的应用。
C++学习记录4——继承和多态
weixin_61015911的博客
01-26 531
C++学习记录5——继承和多态一、继承1.继承的基本语法2.继承方式3.继承中的对象模型4.继承中的构造和析构顺序5.继承中同名成员的处理方式6.继承同名静态成员的处理方式7.多继承语法8.菱形继承（钻石继承）二、多态1.多态基本概念==2.多态的底层原理==3.多态的优点与实例4.纯虚函数和抽象类5.虚析构和纯虚析构 一、继承 继承可减少代码重复，提高利用率 1.继承的基本语法 语法：class 子类:继承方式 父类 子类也称派生类，父类也称基类 派生类中的成员，一部分从基类继承（共性），一部分自己新增（
C++实验二 继承和多态
Keiji582的博客
11-03 779
文章目录实验环境实验内容动态库与静态库继承using的使用友元多态矢量图 实验环境 操作系统：win10 gcc：8.1.0 开发软件：qt5.14.2 实验内容 一、继承访问权限测试 设计类A具有public, protected, private等不同属性的成员函数或变量； 类B通过public, protected, private等不同方式继承A，在类B的成员函数中测试访问A的成员函数或变量； 在类B中添加public, protected, private等不同属性的成员函数或变量，在外部测试访问
java实验：继承和多态
m0_72471315的博客
10-18 1401
由多个功能组合而成，用于巩固继承和多态的知识工具：idea利用继承和多态的知识完成宠物商店宠物的“自我介绍”程序。要求：可以输出许多宠物的信息。输出格式为：我是一只狗。我叫乐乐，是一只黑色的牧羊犬。我会汪汪汪…。这就是本次实验的全部内容了，主要是为了理解和巩固继承和多态的作用，继承还是比较容易理解，但是多态我认为还需要更深入的理解才行（就个人而言）。以上。
C++实验二：继承和多态
qq_45802659的博客
10-25 332
继承和多态一、继承访问权限测试1. 主要内容2. 代码实现main.cppperson.h3.总结二、友元类继承测试1. 主要内容2. 代码实现friend.h3. 总结三、多态性综合应用1. 定义2. 多态实现的条件3. 语法4. 主要内容5. 代码实现一般多态性函数和特殊多态性函数base.cpp析构函数的多态性多继承与虚继承 一、继承访问权限测试 1. 主要内容 （1）设计类Person具有public, protected, private等不同属性的成员函数或变量； （2）类Student，Tea
C++继承和多态
qq_54708796的博客
11-03 445
一、实验内容 1.1、继承访问权限测试 设计类A具有public, protected, private等不同属性的成员函数或变量； 类B通过public, protected, private等不同方式继承A，在类B的成员函数中测试访问A的成员函数或变量； 在类B中添加public, protected, private等不同属性的成员函数或变量，在外部测试访问B的各个成员函数或变量； B以private方式继承A，尝试把A中的部分public成员提升为public。 1.2、友元类继承测试 设计类
C++实验（二）继承和多态
LIAO_0312的博客
10-28 267
目录一、继承访问权限测试1.1 Inherit.cppa. 设计类A具有public, protected, private等不同属性的成员函数或变量：b. 类B通过不同方式继承A，在类B的成员函数中测试访问A的成员函数或变量；c. B以private方式继承A，尝试把A中的部分public成员提升为public。d. 访问权限测试1.2 小结二、友元类继承测试2.1 Inherit_Friend.cppa. 设计类A含有私有变量a，在类A中友元给类C；b. 设计类B继承A，添加私有变量b；在类C中测试访问
C++ 类的继承和多态
wkl132337的博客
10-26 472
文章目录一、实验内容二、实验代码1.继承访问权限测试2.友元类继承测试3.多态的综合应用(1)CShape.h(2)main.cpp(3)CShape.cpp(4)运行截图四、总结1.继承访问权限测试2.继承访问权限测试3.多态的综合应用 一、实验内容 1、继承访问权限测试 设计类A具有public, protected, private等不同属性的成员函数或变量； 类B通过public, protected, private等不同方式继承A，在类B的成员函数中测试访问A的成员函数或变量； 在类B中添加p
计算机本科生c++实验报告.doc
06-22
这份文档是一系列C++编程实验报告的集合，涵盖了多个不同的实验主题，每个实验报告都包含了...7. 心得体会：反映了学生在完成实验后的个人感受和学习收获。 8. 成绩评定标准：列出了评定实验报告成绩的标准和要求。
C++实验报告.doc
05-11
（2）分别为继承和组合方式下为各类添加构造函数、析构函数，增加相应测试代码，体验对象的初始化和构造顺序。 （3）将摄像机类和行车记录仪类功能相近的函数（如拍摄、编码等功能函数）设为同名函数，增加相应测试...
东北大学C++课程设计实验、代码及实验报告
12-19
实验报告通常要求学生详细记录实验目的、步骤、结果分析和遇到的问题及解决方法。这有助于巩固理论知识，提高问题解决能力，同时也便于教师评估学生对课程内容的理解程度。 在完成实验后，学生会编写代码实现实验...
C++实验.rar
05-28
这个"C++实验.rar"压缩包文件显然包含了用于教学和学习目的的C++编程实例。以下是对这些实验可能涉及的知识点的详细解释： 1. **基础语法**：C++的基础语法包括变量声明、数据类型（如int、float、char等）、运算符...
《C++ Primer Plus第五版》
风中的默默
06-26 894
连续分段空间,由一段一段的连续空间构成的，用一小块连续的内存空间map作为主控(不是STL的map容器)，里面的每一个元素都是一个指针，指向另一段连续性内存空间，称作缓冲区，默认使用 512 字节大小。假设我们定义一个双向链表，把链表上节点都定义成shared_ptr智能指针，当其中两个节点互相引用的时候，就会出现循环引用的现象。堆是我们通过new关键字来动态申请的内存空间，堆上分配的内存需要我们手动管理，堆是不连续的内存区域，以链表的形式分配的，如果我们没有正确释放堆上的内存可能会出现内存泄漏。
【代码】c++几个常用的函数
一个小学学霸的博客
06-25 1153
c++函数
C语言从头学26——函数说明符
最新发布
m0_72128260的博客
06-26 1005
本文简要介绍一下extern、static、const等函数说明符的含义及使用。
什么野指针（c++）
qq_35374791的博客
06-24 8518
野指针（Wild Pointer）是指向不确定位置或者非法地址的指针。当一个指针指向的内存被释放后，如果没有将其设置为NULL，那么这个指针就变成了野指针。使用野指针会导致未定义行为，可能引发程序崩溃或数据损坏。
C++之STL（六&七）
CSDN_HZW的博客
06-24 239
【代码】C++之STL（六&七）
java实验三继承和多态
10-17
好的，关于Java实验三继承和多态，我可以为您提供一些基本的知识点和例子。 在Java中，继承是一种重要的面向对象编程概念，它允许一个类（称为子类或派生类）继承另一个类（称为父类或基类）的属性和方法。子类可以...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值