C++ 实验二

一、继承访问权限测试

设计类A具有public, protected, private等不同属性的成员函数或变量；
类B通过public, protected, private等不同方式继承A，在类B的成员函数中测试访问A的成员函数或变量；
在类B中添加public, protected, private等不同属性的成员函数或变量，在外部测试访问B的各个成员函数或变量；
B以private方式继承A，尝试把A中的部分public成员提升为public。

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

class A {
   
public:
	int A_a=100;

protected:
	int A_b=100;

private:
	int A_c=100;
};

class B1:public A 
{
   
public:
	void test() {
   
		A_a = 1;
		A_b = 1;
		//A_c = 1;  //不可访问
	}
	int B1_a=110;

protected:
	int B1_b=110;

private:
	int B1_c=110;
};

class B2 :protected A
{
   
public:
	void test() {
   
		A_a = 2;
		A_b = 2;
		//A_c = 2;  //不可访问
	}
	int B2_a=120;

protected:
	int B2_b=120;

private:
	int B2_c=120;
};

class B3 :private A
{
   
public:
	void test() {
   
		A_a = 1;
		A_b = 1;
		//A_c = 1;  //不可访问
	}
	int B3_a=130;

protected:
	int B3_b=130;

private:
	int B3_c=130;
};

class B4 :private A
{
   
public:
	void test() {
   
		A_a = 3;
		A_b = 3;
		//A_c = 3;   //不可访问
	}
	int B4_a=140;
	using A::A_a;//私有继承，想访问父类的成员，用using提升级别
	using A::A_b;
	//using A::A_c;//原来时private的还是不能访问

protected:
	int B4_b=140;

private:
	int B4_c=140;
};

int main()
{
   
	A a;
	a.A_a;
	//a.A_b;  不可访问
	//a.A_c;  不可访问
	cout << a.A_a<<endl;   //100

	B1 s1;
	s1.B1_a;
	s1.A_a;
	cout << s1.B1_a << endl; //110
	cout << s1.A_a << endl; //100   访问到了A中的A_a
	//s1.B1_b; 不可访问
	//s1.A_b; 不可访问
	//s1.B1_c; 不可访问
	//s1.A_c; 不可访问

	B2 s2;
	s2.B2_a;
	cout << s2.B2_a << endl;  //120
	//s2.A_a; 不可访问    protected类型继承，连父类的共有成员都不能访问
	//s2.B2_b; 不可访问
	//s2.A_b; 不可访问
	//s2.B2_c; 不可访问
	//s2.A_c; 不可访问

	B3 s3;
	s3.B3_a;
	cout << s3.B3_a << endl;  //130
	//s3.A_a; 不可访问
	//s3.B3_b; 不可访问
	//s3.A_b; 不可访问
	//s3.B3_c; 不可访问
	//s3.A_c; 不可访问

	B4 s4;
	s4.A_a;
	s4.A_b;
	s4.B4_a;
	cout << s4.A_a << endl;  //100
	cout << s4.A_b << endl;  //100  因为using提升了私有继承的等级，所以可以访问父类中的public和protected
	cout << s4.B4_a << endl;  //140
	//s4.B4_b; 不可访问
	//s4.B4_c; 不可访问
	//s4.A_c; 不可访问  但是父类中private类型的还是不能访问
	return 0;
}

二、友元类继承测试

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

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

class A {
   
private:
	int a;
	friend class C;
};

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

class C
{
   
public:
	void test() {
   
		B b1;
		//b1.b;  不可访问！
	}
};

class D :public C
{
   
public:
	void test() {
   
		A a1;
		//a1.a;  //不可访问  朋友的儿子不能访问我的私有变量
		B b2;
		//b2.b;  //不可访问  
		//b2.a;   //不可访问 不能访问父亲的私有变量
	}
};

三、多态性综合运用

一般多态性函数：输入输出参数完全一样，在父类中添加virtual；
特殊多态性函数：输入或输出参数在子类中是父类的指针或基类的引用，在子类中对于的是子类的指针或子类的引用；
析构函数的多态性；
多继承，注意什么情况需要虚继承；
设计矢量图，运用多继承设计组合图形，要求具备创建不同类型矢量图、选择图形、移动图形、用不同颜色显示图形（表示选中与否），用vector或数组管理图形。

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);
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);