关于类和对象的分文件编写----点圆判断实例

1.简介

本文通过一个判断点和圆位置关系的实例，来记录C++中类和对象分文件编写的过程。

2.分文件前代码

#include<iostream>
using namespace std;
//点和圆的关系

//点类
class Point {
private:
	int d_x; // 横坐标
	int d_y;// 纵坐标
public:
	void setLocation(int x,int y) {  //设置坐标
		d_x = x;
		d_y = y;
	}
	int getDx() {
		return d_x;
	}


	int getDy() {
		return d_y;
	}
	

};

//圆类
class Circle {
public:
	void setR(int r)  //设置半径
	{
		Y_r = r;
	}

	void setPoint(Point p)//设置圆心
	{
		o = p;
	}

	Point getPoint() //读取圆心
	{
		return o;
	}
	
	int getR() //读取半径
	{
		return Y_r;
	}
	
private:
	//在类中可以让另一个类作为本类做的一个成员
	Point o;
	int Y_r;//半径
};

void judge(Circle& C,Point &P)
{

	int m = (P.getDx() - C.getPoint().getDx()) * (P.getDx() - C.getPoint().getDx()) + (P.getDy() - C.getPoint().getDy()) * (P.getDy() - C.getPoint().getDy());
	int r = C.getR() * C.getR();

	
	if (m > r)
	{
		cout << "点在圆外！" << endl;

	}
	else if (m == r) {

		cout << "点在圆上!" << endl;

	}
	else
	{
		cout << "点在圆内！" << endl;
	}

}
int main()
{
	Circle C1;
	Point center;//定义圆心，不然point类没办法对private里的o进行操作！！！！
	center.setLocation(0, 0);

	C1.setPoint(center);
	
	C1.setR(2);


	Point p1;
	p1.setLocation(2, 5);
	Point p2;
	p2.setLocation(1, 1);
	Point p3;
	p3.setLocation(0, -2);
	cout << "p1:" << endl;
	judge(C1,p1);
	cout << "p2:" << endl;
	judge(C1,p2);
	cout << "p3:" << endl;
	judge(C1,p3);

	system("pause");
	return 0;
}

这个代码由于在主函数前既定义了一个判断函数，还定义了两个类，显得有些杂乱，因此我们需要进行分文件编写来美化我们的代码。

3.分文件编写步骤

类和对象分文件编写其实和函数的分文件编写类似

1）先创建一个后缀名为.h的头文件

2）再创建一个.cpp为后缀名的源文件

3）在头文件中写声明

4）在源文件中写定义

具体可以参考这篇关于函数的分文件编写

4.分文件编写实现

1）文件列表

创建如下文件列表存放类和函数

2）point.h（点类头文件）

#pragma once
#include<iostream>
using namespace std;
//点类
class Point {
private:
	int d_x; // 横坐标
	int d_y;// 纵坐标
public:
	void setLocation(int x, int y);  //设置坐标
	
	int getDx();

	int getDy();


};

在头文件中写 Point类的 声明，删去原来定义的内容。

其中 # pragma once 代表让编译器只运行一次，防止重复运行。

3）point.cpp（点类源文件）

#include"point.h"
//因为下面的函数都是成员函数，所以需要告诉编译器实在point作用域下的成员函数

void Point::setLocation(int x, int y) {  //设置坐标
	d_x = x;
	d_y = y;
}
int Point::getDx() {
	return d_x;
}


int Point::getDy() {
	return d_y;
}

源文件中写类的定义函数

void Point::setLocation(int x, int y) 中的 Point:: 是为了告诉编译器这是在Point作用域下的成员函数，后面的成员函数定义也是这样。

4）circle.h（圆头文件）

#pragma once
#include<iostream>
#include"point.h"  //在圆类中有点类的调用，因此要在圆类的头文件中引用点类的头文件
using namespace std;
class Circle {
public:
	void setR(int r);  //设置半径
	

	void setPoint(Point p);//设置圆心
	
	Point getPoint();//读取圆心
	

	int getR(); //读取半径
	
private:
	//在类中可以让另一个类作为本类做的一个成员
	Point o;
	int Y_r;//半径
};

和点类头文件一样，做圆类的声明，但是在圆类中运用了点类作为其函数成员，因此在头文件中要引用点类的头文件

5）circle.cpp

#include"circle.h"

void Circle::setR(int r)  //设置半径
{
	Y_r = r;
}

void Circle::setPoint(Point p)//设置圆心
{
	o = p;
}

Point Circle::getPoint() //读取圆心
{
	return o;
}

int Circle::getR() //读取半径
{
	return Y_r;
}

和点类一样，在源文件中定义了圆类的成员函数

6）judge.h（judge函数的头文件）

函数的分文件编写和类的类似，都是在头文件中写定义，在源文件中写声明。

#pragma once
#include<iostream>
#include"circle.h"
#include"point.h"
using namespace std;
void judge(Circle& C, Point& P);

由于其这个函数引用了圆类和点类，要在函数的头文件中对圆类和点类做一个声明。

7）judge.cpp（judge函数的源文件）

#include"judge.h"
void judge(Circle& C, Point& P)
{

	int m = (P.getDx() - C.getPoint().getDx()) * (P.getDx() - C.getPoint().getDx()) + (P.getDy() - C.getPoint().getDy()) * (P.getDy() - C.getPoint().getDy());
	int r = C.getR() * C.getR();


	if (m > r)
	{
		cout << "点在圆外！" << endl;

	}
	else if (m == r) {

		cout << "点在圆上!" << endl;

	}
	else
	{
		cout << "点在圆内！" << endl;
	}

}

源文件中写 judge函数的定义。

8)主函数

#include<iostream>
#include"circle.h"
#include"point.h"
#include"judge.h"
using namespace std;

int main()
{
	Circle C1;
	Point center;//定义圆心，不然point类没办法对private里的o进行操作！！！！
	center.setLocation(0, 0);

	C1.setPoint(center);
	
	C1.setR(2);


	Point p1;
	p1.setLocation(2, 5);
	Point p2;
	p2.setLocation(1, 1);
	Point p3;
	p3.setLocation(0, -2);
	cout << "p1:" << endl;
	judge(C1,p1);
	cout << "p2:" << endl;
	judge(C1,p2);
	cout << "p3:" << endl;
	judge(C1,p3);

	system("pause");
	return 0;
}

主函数中只要引入要用到的类和函数的头文件即可实现其功能。

结语

通过类和对象的分文件编写，可以将一堆杂乱的代码分成数个简单的代码文件，使代码更具有可读性。