C++实验二：继承和多态

一、继承访问权限测试

1. 主要内容

（1）设计类Person具有public, protected, private等不同属性的成员函数或变量；
（2）类Student，Teacher，worker通过public, protected, private等不同方式继承Person，在继承类的成员函数中测试访问父类Person的成员函数或变量；
（3）在继承类中添加public, protected, private等不同属性的成员函数或变量，在外部测试访问继承类的各个成员函数或变量；
（4）继承类worker以private方式继承Person，尝试把Person中的部分private成员提升为public。

2. 代码实现

main.cpp

#include <iostream>
#include "person.h"
using namespace std;

int main()
{
	Person p;
	p.m_strName;
	//p.m_strSex; 都不能访问，外部访问只能访问public
	//p.m_Age

	Student s;
	s.m_strName;
	//s.m_strSex;无法访问
	//s.m_Age;
	s.s1;
	//s.s2;无法访问
	//s.s3

	Teacher t;
	t.m_strName;//通过protected继承后，成员函数和变量都降级为protected，原本无法访问，但是可以通过using 父类::成员;语句改写为公有
	t.m_strSex;
	//t.m_Age; 无法访问
	t.t1;
	//t.t2;无法访问
	//t.t3;

	worker w;
	w.m_strName;//升级为public，外部可以访问
	//w.m_strSex; 
	//w.m_Age
	return 0;
}

person.h

#pragma once
#ifndef PERSON_H
#define PERSON_H
#include<string>
using namespace std;

//设计类Person具有public, protected, private等不同属性的成员函数或变量
class Person
{
public:
	Person();
	string m_strName;
protected:
	string m_strSex;
	void SetSex(string strSex = "")
	{
		m_strName = "";
		m_strSex = strSex;
	}
private:
	int m_Age;
};

//类Student通过public方式继承Person，测试访问Person的成员函数和变量
class Student :public Person  //继承下来级别都为不变，只能降级不能升级
{
public:
	//内联函数不能放在cpp文件中
	//隐式内联函数
	void SetSex(string strSex = "")//无论继承方式是什么，都可以访问到protected以上的变量和成员函数
	{
		m_strName = "";   //内部能访问父类的protected以上的变量和成员函数，外部main只能访问public
		m_strSex = strSex;  
		//m_Age = ""；private不可访问
	}
	string GetSex();
	int s1;
protected:
	int s2;
private:
	int s3;
};

//类Teacher通过protected方式继承Person，测试访问Person的成员函数和变量
class Teacher :protected Person //函数和变量级别都变为protected
{
public:
	//可以把protected都变为public
	using Person::m_strName;
	using Person::m_strSex;
	//using Person::m_Age; 私有的不能升级
	void SetSex(string strSex = "")//父类子类中都有，main中调用是调用子类的，但是无法调用protected中的函数
	{
		m_strName = "";
		m_strSex = strSex;
		//m_Age = "";private不可访问
	}
	string GetSex()
	{
		return m_strSex;
	}
	int t1;
protected:
	int t2;
private:
	int t3;
};

//类worker通过private方式继承Person，测试访问Person的成员函数和变量
class worker :private Person
{
public:
	using Person::m_strName;//升级为public，外部可以访问
	void Set()
	{
		m_strName = "";
		m_strSex = "";
		//m_Age = "";private不可访问
	}
	int w1;
protected:
	using Person::m_strSex;//外部依旧无法访问，因为外部只能访问public部分，所以应该放在public中
	using Person::m_strSex;
	//using Person::m_Age; no,原因：没有访问基类private的权限
	int w2;
private:
	int w3;
};

//显式内联函数
inline string Student::GetSex()
{
	return m_strSex;
}
#endif // !pPERSON_H

3.总结

（1）继承方式：基类成员在派生类中的访问权限不得高于继承方式中指定的权限。

（2）子类可以访问父类的public和protected，外部只能访问public。不管继承方式如何，基类中的 private 成员在派生类中始终不能使用（不能在派生类的成员函数中访问或调用）。
（3）通过using 父类::成员;使用 using 关键字可以改变基类成员在派生类中的访问权限，例如将 public 改为 private、将 protected 改为 public。放于派生类中的public就改变为public，放在protected和private中同理。可升可降。

注意：using 只能改变基类中 public 和 protected 成员的访问权限，不能改变 private 成员的访问权限，因为基类中 private 成员在派生类中是不可见的，根本不能使用，所以基类中的 private 成员在派生类中无论如何都不能访问。

class worker :private Person
{
public:
	using Person::m_strName;//升级为public，外部可以访问
	using Person::m_strSex;
	//using Person::m_Age; no,原因：没有访问基类private的权限
	void Set()
	{
		m_strName = "";
		m_strSex = "";
		//m_Age = "";private不可访问
	}
	int w1;
protected:
	using Person::m_strSex;//外部依旧无法访问，因为外部只能访问public部分，所以应该放在public中
	int w2;
private:
	int w3;
};

这里可能有人会有疑问，为什么worker通过private的方式继承，通过
using可以使m_strSex变为public，实际上是因为m_strSex在父类中是protected，子类可以访问父类的protected和public，所以显而易见，using Person::m_Age就是不可行的，因为m_Age在父类中是private，子类没有访问父类中private的权限。

二、友元类继承测试

1. 主要内容

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

2. 代码实现

friend.h

#pragma once
#ifndef FRIEND_H
#define FRIEND_H
#include<iostream>
using namespace std;

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

class B :public A
{
private:
	int b;
	//friend class C;
};

class C
{
public:
	void TestFriend()
	{
		A a1;
		a1.a;
		B b1;
		b1.a;//类A中友元给类C，则可以访问私有变量a
		//b.b;类B没有友元给类C，无法访问私有变量b
	}
};

class D:public C
{
public:
	void TestFriend()
	{
		A a2;
		//a2.a; 无法访问，友元不能继承
		B b2;
		//b2.a; 无法访问
		//b2.b; 无法访问
	}
};
#endif // FRIEND_H

3. 总结

（1）当类A友元给类B时，则B可访问A中所有成员函数和变量。
（2）友元类不能继承。
（3）友元关系是单向的，不具有交换性。若类B是类A的友元，类A不一定是类B的友元.
（4）友元关系不具有传递性。若类B是类A的友元，类C是B的友元，类C不一定是类A的友元。

三、多态性综合应用

1. 定义

（1）多态是指同样的消息被不同类型的对象接收时导致不同的行为，所谓消息是指对类的成员函数的调用，不同的行为是指不同的实现，也就是调用了不同的函数。简单来说，举个例子：你妈喊吃饭了，你和你爹接收到了这个同样的信息，做了不同的事情，你装饭上菜，你爹拿碗筷 。
（2）多态按其实现的时机又分为编译时多态和运行时多态。多态的类型又有重载多态、强制多态、包含多态和参数多态。

2. 多态实现的条件

（1）必须是公有继承；
（2）必须是通过基类的指针或引用，指向派生类对象访问派生类方法；
（3）基类的方法必须是虚函数，且完成了虚函数的重写。

3. 语法

一般虚函数成员的声明语法是：virtual 函数类型 函数名（形参表）;

4. 主要内容

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

5. 代码实现

一般多态性函数和特殊多态性函数

base.cpp

#include <iostream>
using namespace std;

class Base1 //基类Base1定义
{
public:
	virtual void display() const;//虚函数
};
void Base1::display() const
{
	cout << "Base1:display()" << endl;
}

class Base2 :public Base1  //共有派生类Base2定义，必须共有继承
{
public:
	void display() const; //一般多态性函数，覆盖基类的虚函数，void前面可加上virtual，可有可无
};
void Base2::display() const
{
	cout << "Base2::display()" << endl;
}

class Derived : public Base2  //共有派生类Derived定义
{
public:
	void display() const;  //覆盖基类的虚函数
};
void Derived :: display() const
{
	cout << "Derived::display()" << endl;
}

void fun(Base1* ptr)    //特殊多态性函数，参数为指向基类对象的指针
{
	ptr->display();     //“对象指针->成员名”
}

void fun(Base1& ptr)    //通过引用来访问虚函数
{
	ptr.display();
}
int main()
{
	Base1 base1;          //定义Base1类对象
	Base2 base2;		  //定义Base2类对象
	Derived derived;	  //定义Derived类对象
	fun(&base1);		  //用Base1对象的指针调用fun函数
	fun(&base2);		  //用Base2对象的指针调用fun函数
	fun(&derived);		  //用Derived对象的指针调用fun函数
	return 0;
}

Base2中display函数与基类中原型一样，而基类中函数前加上virtual为虚函数吗，则其就是为虚函数。目的是告诉编译器它是虚函数，要进行晚绑定。

实现机制：为每一个具有虚函数的类准备了一个虚函数的表。当类中出现virtual时,C++编译器会对象添加一个vptr指针,同时会产生一个虚函数表
！！虚指针是无法通过函数找到的，无法显示访问，隐含的。作用就是为了寻找虚函数。

析构函数的多态性

为什么需要虚析构函数?
（1）可能通过基类指针删除派生类对象;
（2）如果你打算允许其他人通过基类指针调用对象的析构函数（通过delete这样做是正常的)，就需要让基类的析构函数成为虚函数，否则执行delete的结果是不确定的。

xuxigou.cpp

#pragma once
#ifndef XUXIGOU_H
#define XUXIGOU
#include <iostream>
using namespace std;

class Base
{
public:
	~Base();
};
Base::~Base()
{
	cout << "Base destructor" << endl;
}

class Derived :public Base
{
public:
	Derived();
	~Derived();
private:
	int* p;
};
Derived::Derived()
{
	p = new int(0);
}
Derived::~Derived()
{
	cout << "Derived destructor" << endl;
	delete p;
}

void fun(Base* b)
{
	delete b;
}

int main()
{
	Base* b = new Derived();
	fun(b);
	return 0;
}
#endif // !XUXIGOU_H

运行时输出信息为：

这说明，通过基类指针删除派生类对象时调用的是基类的析构函数，派生类的析构函数没有被执行，因此派生类对象中动态分配的内存空间没有得到释放，造成了内存泄露。也就是说派生类对象成员p所指向的内存空间，在对象消失后既不能被本程序继续使用也没有被释放。对于内存需求量较大、长期连续运行程序来说，如果持续发生这样的错误是很危险的，最终将导致因内存不足而引起的程序终止。
避免上述错误的有效方法就是将析构函数声明为虚函数:

class Base
{
public :
	virtual ~ Base ();
};

这时运行时的输出信息为:
Derived destructor
Base destructor
这说明派生类的析构函数被调用了，派生类对象中动态申请的内存空间被正确地释放了。这是由于使用了虚析构函数，实现了多态。

多继承与虚继承

#pragma once
#ifndef DUOJICHENGANDXUJICHENG_H
#define DUOJICHENGANDXUJICHENG_H
#include<iostream>
using namespace std;

class A
{
public:
	int a;
};

class B1 :virtual public A //虚继承，当类中出现virtual时,C++编译器会对象添加一个vptr指针,同时会产生一个虚函数表
{
public:
	int b1;
};

class B2 :virtual public A
{
public:
	int b2;
};

class C :public B1, public B2
{
public:
	void fun()
	{
		int  i = a; //B1、B2若是不虚继承会报错，因为多继承原因，C同时继承B1，B2，而B1、B2的基类又相同，则不知道是B1的a还是B2的a
	}
};
#endif // !DUOJICHENGANDXUJICHENG_H

多继承：
c++不仅可以单继承，也可以多继承。语法为：
class 派生类名：继承方式 基类名1，继承方式 基类名2，…
{
派生类成员声明;
};
多继承会出现的问题：
如上述代码所示，若类A是类B1、B2的基类，类B1、B2又是类C的基类，则类C就会有两份A的成员，当访问时就会出现错误，不知道访问哪一个。
解决方法：
虚继承，在B1、B2的继承方式前加上virtual，当类中出现virtual时,C++编译器会对象添加一个vptr指针,同时会产生一个虚函数表。这时类C访问则是通过虚函数表，就不会出现选择上的问题。

多继承的应用

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

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

CShape.h

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

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

运行结果