C++实验二（继承和多态）

目录

一、继承访问权限测试

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

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

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

4、D以private方式继承A，尝试把A中的部分public成员提升为public。

二、友元类继承测试 

1、设计类A含有私有变量a，在类A中友元给类C；

 2、设计类B继承A，添加私有变量b；在类C中测试访问类B的成员变量a, b;

3、 设计类D继承C，在D的成员函数中测试访问类A的成员变量a，类B的成员变量a, b。

三、多态性综合运用

1.一般多态性函数：输入输出参数完全一样，在父类中添加virtual；

​2.特殊多态性函数：输入或输出参数在子类中是父类的指针或基类的引用，在子类中对于的是子类的指针或子类的引用；

​3.析构函数的多态性；

​

4.多继承，注意什么情况需要虚继承；

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

四、总结 

1、继承访问权限

2、友元类

3、多态

一、继承访问权限测试

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

class A {
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};

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

class B :public A {
public:
	void test01(){
		m_A = 10;
		m_B = 20;
		//m_C = 30;//B公共继承A可以访问A中的public和protected属性，private属性访问不到
	}
	int m_B_A;
protected:
	int m_B_B;
private:
	int m_B_C;
};
class C :protected A {
public:
	void test02() {
		m_A = 10;
		m_B = 20;
		//m_C = 30;//C公共继承A可以访问A中的public和protected属性，private属性访问不到
	}
	int m_C_A;
protected:
	int m_C_B;
private:
	int m_C_C;
};
class D :private A {
public:
	void test03() {
		m_A = 10;
		m_B = 20;
		//m_C = 30;//D公共继承A可以访问A中的public和protected属性，private属性访问不到
	}
	using A::m_A;
	//D以private方式继承A，用using A::m_A可以把A中的部分public成员提升为public。
	int m_D_A;
protected:
	int m_D_B;
private:
	int m_D_C;
};

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

void test() {
	A a;
	a.m_A ;
	//a.m_B;protected属性在类外不可访问
	//a.m_C;private属性在类外不可访问

	B b;
	b.m_A;
	b.m_B_A;
	//b.m_B;
	// b.m_B_B;
	//b.m_C;
	//b.m_B_C;

	C c;
	c.m_C_A;
	//c.m_A; c.m_B; c.m_C_A;
	//C保护继承A在类外访问不到A中的成员变量
	//c.m_C_B;c.m_C_C;
	//protected和private属性在类外访问不到

	D d;
	d.m_A;
	//using A::m_A可以把A中的部分public成员提升为public，在类外可以访问A中的m_A;
	d.m_D_A;
	// d.m_B; d.m_C_A;
	//D私有继承A在类外访问不到A中的成员变量
	//d.m_D_B;d.m_D_C;
	//protected和private属性在类外访问不到
}

4、D以private方式继承A，尝试把A中的部分public成员提升为public。

 

二、友元类继承测试 

1、设计类A含有私有变量a，在类A中友元给类C；

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

 2、设计类B继承A，添加私有变量b；在类C中测试访问类B的成员变量a, b;

class B : private A {
private:
	int m_B;
};
class C {
public:
	void test01() {
		B b;
		b.m_A = 10;
		//b.m_B = 10;//在类A中友元给类C，可以访问A中私有成员变量，但不可访问B中私有成员变量；
	}
};

3、 设计类D继承C，在D的成员函数中测试访问类A的成员变量a，类B的成员变量a, b。

class D : private C {
public:
	void test02(){
		A a;
		//a.m_A = 10;
		B b;
		//b.m_A = 20;
		//b.m_B = 30;
		//类A中友元给类C，但D继承C无法访问类A和类B中的成员变量
	}
};

三、多态性综合运用

1.一般多态性函数：输入输出参数完全一样，在父类中添加virtual；

#include
using namespace std;

class Animal {
public:
	Animal(){}
	Animal(int legs) {
		m_legs = legs;
	}
	virtual void Move() {
		cout << "this is Aniaml" << endl;
	}
protected:
	int m_legs;
};
//Animal::Animal(){
//	
//}
class Cat : virtual public Animal {
public:
	Cat(){}
	Cat(int legs) {
		m_legs = legs;
	}
	virtual void Move() {
		cout << "this is Cat" << endl;
	}
};
class Dog : virtual public Animal {
public:
	Dog(){}
	Dog(int legs) {
		m_legs = legs;
	}
	virtual void Move() {
		cout << "this is Dog" << endl;
	}
};
class Hen :  public Cat,public Dog {
public:
	Hen(){}
	Hen(int legs) {
		m_legs = legs;
	}
	virtual void Move() {
		cout << "this is Hen" << endl;
	}
};
void test01() {
	

	Animal* pA[4];
	pA[0] = new Animal(0);
	pA[1] = new Cat(4);
	pA[2] = new Dog(4);
	pA[3] = new Hen(2);
	for (int i = 0; i < 4; i++) {
		pA[i]->Move();
	}
}
int main() {
	test01();
	system("pause");
	return 0;
}

2.特殊多态性函数：输入或输出参数在子类中是父类的指针或基类的引用，在子类中对于的是子类的指针或子类的引用；

添加函数doMove(),然后通过引用调用

void doMove(Animal& animal) {
	animal.Move();
}

    Animal an;
	Cat cat;
	Dog dog;
	Hen hen;
	doMove(an);
	doMove(cat);
	doMove(dog);
	doMove(hen);

3.析构函数的多态性；

 我们在应用C++的多态特性时，常常会碰到一种情况，就是当指向基类的指针被释放时，派生类的析构函数其实没有被调用，导致在派生类中申请的空间没有被释放，导致内存泄漏。

#include 
using namespace std;

class Mammal {
public:
    Mammal() { cout << "Mammal构造函数" << endl; }
    ~Mammal() { cout << "Mammal 析构函数"<< endl; }
    virtual void Speak() const { cout << "Mammal speak!" << endl;; }
};

class Dog :public Mammal {
public:
    Dog() {
        p = new int(0);
        cout << "Dog 构造函数" << endl;
    }
    ~Dog() {
        cout << "Dog 析构函数" << endl;
        delete p;
    }
    void Speak() const { cout << "Woof!" << endl; }
private:
    int* p;
};

int main() {
    Mammal* pDog = new Dog;
    pDog->Speak();
    delete pDog;
    return 0;
}

由运行结果可知：

派生类Dog的析构函数没有调用，Dog的构造函数申请的空间泄漏了。

此时，虚析构函数能够有效的防止这种情况的出现。

使用虚析构后

#include 
using namespace std;

class Mammal {
public:
    Mammal() { cout << "Mammal构造函数" << endl; }
    virtual ~Mammal() { cout << "Mammal 析构函数"<< endl; }
    virtual void Speak() const { cout << "Mammal speak!" << endl;; }
};

class Dog :public Mammal {
public:
    Dog() {
        p = new int(0);
        cout << "Dog 构造函数" << endl;
    }
    ~Dog() {
        cout << "Dog 析构函数" << endl;
        delete p;
    }
    void Speak() const { cout << "Woof!" << endl; }
private:
    int* p;
};

int main() {
    Mammal* pDog = new Dog;
    pDog->Speak();
    delete pDog;
    return 0;
}

4.多继承，注意什么情况需要虚继承；

如图，假如存在如下图继承关系，CCat和CEagle继承自CAnimal,COwl又继承自CCat和CEagle。

---

 实验结果表明：

如果一个派生类从多个基类派生，而这些基类又有一个共同的基类，则在对该基类中声明的成员进行访问时，可能产生二义性。

解决方法：

消除成员访问时的二义性，虚继承便可消除二义性，要使某个公共基类在派生类中只产生一个子对象，必须将该基类声明为虚继承，使这个基类成为虚基类；虚继承是在继承时使用关键字virtual将被继承的类声明为虚基类，使公共基类的成员在重复继承的派生类中只产生一个拷贝。

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

Main.cpp

#include
#include "graphics.h"
#include
#include "CShape.h"
using namespace std;
int main()
{
    //初始化画布大小为800*600
    initgraph(800, 600);
    setbkcolor(WHITE);
    delay_ms(0);
    //设置画图颜色
    setcolor(BLACK);
    setfont(18, 0, "宋体");
    setbkmode(TRANSPARENT);
    
    vectorshapes;
    vectorshapestmp;
    //初始化一个矩形、三角形、符合图形
    shapes.push_back(new CTriangle(CPoint(220, 220), CPoint(350, 380), CPoint(540, 350)));
    shapes.push_back(new CRect(CPoint(200, 50), CPoint(400, 100)));
    shapes.push_back(new Comgraphics(CRect(CPoint(150, 450))));
    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
#include
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 
using namespace std;
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() {}
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() {}
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() {}
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;
}

运行截图：可以实现画矩形，三角形，组合图行，选中图形，移动、复制、粘贴功能。

四、总结 

1、继承访问权限

• B以private方式继承A，用{using A::_a; }把A中的部分public成员提升为public
• 如果想让这些继承而来的数据成员作为public或者protected成员，可以用using重新声明。using声明语句中名字的访问权限由该using声明语句之前的访问说明符决定
   

2、友元类

• 当类Y被说明为类X的友元时，类Y的所有成员函数都成为类X的友元函数，这就意味着作为友元类Y中的所有成员函数都可以访问类X中的所有成员（包括私有成员）。
   
• 友元关系是单向的，不具有交换性。友元关系也不具有传递性。友元关系不能被继承，基类的友元类未必是子类的友元，某类型的友元的子类未必是该类型的友元。

3、多态

• 多态按字面的意思就是多种形态。当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。
• C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。
• 虚函数是在基类中使用关键字 virtual 声明的函数。在派生类中重新定义基类中定义的虚函数时，会告诉编译器不要静态链接到该函数。