【C++】构造函数、析构函数、运算符重载及友元函数

别看ID看黑板
154 阅读4分钟

本文已参与「新人创作礼」活动，一起开启掘金创作之路。

【C++】构造函数、析构函数、运算符重载及友元函数

一、实验目的与要求

将矢量图封装成动态库在主程序中用AutoPtr类管理图形指针的自动内存释放在主程序中用自己设计的Queue或Stack存储AutoPrt<图形>

二、实验结果

1.初始图形

image.png

2.移动、复制与创建操作后图形

image.png

三、实验分析与总结

在实验中创建动态图形库时，误把动态库项目视为Console Application项目，导致无法调用。后在老师上课期间的知道下正确的创建DLL项目，完成了动态图形库的创建。在后续实验中由于系统Bug在对dll动态库进行修改时，无法正确的更新在Cshape中，由于无法解决，最终重新新建了项目重新调用dll动态库文件。最终成功将矢量图封装成为动态库，并且能够正确调用。

同时也再次复习了前几次实验的内容，包括继承、多态与友元类等：对于各个图形的操作设置了共有继承类例如CShape，而其他一些类例如CPoint、CTriangle与CRect通过public、protect与private这些方式继承了CShape。使得CPoint等这些派生类可以从基类CShape中获得其自身不曾定义过的成员，并且这让CPoint等类与基类CShape中的成员具有相同的属性，提高编程效率；在多态性方面，对输入输出完全一样的一般性多态函数做出了定义，例如virtual double GetArea()；对于其他例如析构函数也做出了多态性说明，例如：virtual ~CShape()。

对于智能指针也同样运用其负责自动释放所指向的对象，对图形的存储进行很好的管理。实验中AutoPtr智能指针的作用是管理一个指针，因为项目存在以下这种情况：系统申请的空间在函数结束时忘记释放，造成内存泄漏。所以智能指针的作用原理就是在函数结束时自动释放内存空间，不需要手动释放内存空间。

因此我们在在构造函数时，将类外需要管理的指针传进去，可以给个空的缺省值，然后重载CShape图形操作过程中需要用到的运算“+”“=”“-”等符号用于，然后在析构函数时，释放这个指针空间，形成对这个指针的智能的管理。

    通过在DevC++平台上不断的进行实验实践，出现错误与通过老师和同学的帮助解决错误，逐渐对C++项目编程更加熟练。虽然仍有很多知识尚未了解与学习，对于项目编码也尚不够精炼，但在这些实验中深入了解的很多编码原则与知识，不断的学习与进步，潜移默化的提升了计算机学子的基础技能——编程。

四、关键源代码

dll动态库文件

/* Replace "dll.h" with the name of your header */
#include "dll.h"
#include <windows.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::DrawFig(){
}
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::DrawFig() {
}

CShape* CPoint::Clone() const {
	return new CPoint(*this);
}

CShape& 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(const CPoint &pt)
{
	CPoint* pt1 = new CPoint(pt.m_nPosX + 100, pt.m_nPosY + 70);
	CPoint* pt2 = new CPoint(pt.m_nPosX, pt.m_nPosY + 70);
	m_pts[0] = pt;
	m_pts[1] = *pt1;
	m_pts[2] = *pt2;

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

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(GREEN);              //设置填充色 
	fillpoly(4, poly);  //4为边数，poly存储各顶点坐标 
}

void CTriangle::DrawFig() {
	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(YELLOW);
	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 ((double)m_ptBR.m_nPosX - (double)m_ptLT.m_nPosX)*((double)m_ptBR.m_nPosY - (double)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 {
	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 };
	setfillcolor(GREEN);
	fillpoly(5, pts);
}

void CRect::DrawFig() {
	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 };
	setfillcolor(YELLOW);
	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;

}

//CRecTri 
CRecTri::CRecTri(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) /

mian.cpp

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

int main()
{
	initgraph(640, 480, INIT_RENDERMANUAL);
	setbkcolor(WHITE);                                            
	setcolor(BLACK);                    
	setfont(20, 0, "楷体");
	setbkmode(TRANSPARENT);             
	vector<CShape*>shapes;
	vector<CShape*>shapestmp;

	shapes.push_back(new CTriangle(CPoint(450, 100), CPoint(400, 200), CPoint(500, 200))); 	shapes.push_back(new CRect(CPoint(250, 100), CPoint(350, 200)));
	shapes.push_back(new CRecTri(CRect(CPoint(100, 100), CPoint(200, 200))));

	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;
							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]->DrawBlue();
				else
					shapes[i]->Draw();
			}
		}
		while (kbmsg()) {
			key_msg msgk = getkey();
			if (msgk.key == key_A && 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()) {
					if (msgm.is_down()) {
						shapes.push_back(new CRectTri(CRect(CPoint(msgm.x, msgm.y))));
						redraw = true;
					}
				}*/
			}
			if (msgk.key == key_Z && 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)) {
								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;
}
avatar
文章
阅读
粉丝