C++学习笔记（十一）

一、类和对象

C++面向对象的三大特性为：封装、继承、多态

C++认为万事万物皆为对象，对象上有其属性和行为

例如：人可以作为对象，属性有姓名、年龄、身高......，行为有走、吃、睡觉

           车也可以作为对象，属性有轮胎、方向盘、车灯......，行为有载人

           具有相同性质的对象，我们可以抽象称为类，人属于人类，车属于车类

1.1 封装

1.1.1 封装的意义

① 将属性（成员属性、成员变量）和行为（成员函数、成员方法）作为一个整体（成员），表现生活中的事物

② 将属性和行为加以权限控制

封装意义一：

#include 

using namespace std;

#define PI 3.14

class Circle
{
public:
	int c_r;

	double calculate_zc()
	{
		return 2 * PI * c_r;
	}
};

int main(int argc, char* argv[])
{
	Circle circle1;
	circle1.c_r = 10;
	cout << "圆的周长为:" << circle1.calculate_zc() << endl;
}

封装意义二：

类在设计时，可以把属性和行为放在不同的权限下加以控制

访问权限有三种：

1. public 公共权限：成员 类内可以访问 类外可以访问        

2. protected 保护权限：成员 类内可以访问 类外不可以访问 子类可以访问父类中的保护内容        

 3. private 私有权限：成员 类内可以访问 类外不可以访问 子类不可以访问父类中的私有内容

1.1.2 struct和class的区别

在C++中struct和class唯一的区别就在于默认的访问权限不同

struct默认权限为公共，class默认权限为私有

1.1.3 成员属性设置为私有

优点1：将所有成员属性设置为私有，可以自己控制读写权限

优点2：对于写权限，可以检测数据的有效性

#include 
#include 

using namespace std;

class Student
{
private:
	string stu_Name; // 可读可写
	string stu_Num = "23S101111"; // 只读
	int stu_Age; // 只写

public:
	void setName(string name) 
	{
		stu_Name = name; // 可写
	}
	string getName()
	{
		return stu_Name; // 可读
	}
	string getNum()
	{
		return stu_Num; // 只读
	}
	void setAge(int age)
	{
		if (age < 0 || age>150) // 检测数据有效性
		{
			cout << "年龄输入有误，已重置为0" << endl;
			stu_Age = 0;
			return;
		}
		stu_Age = age; // 只写
	}
};

int main(int argc, char* argv[])
{
	Student stu;
	stu.setName("张三");
	cout << stu.getName() << endl;
	// stu.stu_Num = "23S101111"; 报错，不可写
	cout << stu.getNum() << endl; 
	stu.setAge(150);
	stu.setAge(151);
	// cout << stu.stu_Age << endl;  报错，不可读
}

#include 

using namespace std;

// 立方体类设计
// 1. 创建立方体类
// 2. 设计立方体属性 获取立方体的长宽高
// 3. 设计立方体行为 获取立方体面积和体积
// 4. 分别利用全局函数和成员函数 判断两个立方体是否相等

class Cube
{
private:
	double cube_L, cube_W, cube_H;

public:
	void setL(double length)
	{
		cube_L = length;
	}
	double getL()
	{
		return cube_L;
	}
	void setW(double width)
	{
		cube_W = width;
	}
	double getW()
	{
		return cube_W;
	}
	void setH(double height)
	{
		cube_H = height;
	}
	double getH()
	{
		return cube_H;
	}
	double calculate_S()
	{
		return  2 * (cube_L * cube_W + cube_L * cube_H + cube_W * cube_H);
	}
	double calculate_V()
	{
		return cube_L * cube_W * cube_H;
	}
	bool isSameByClass(Cube &cube)
	{
		if (cube_L == cube.getL() && cube_W == cube.getW() && cube_H == cube.getH())
		{
			return	true;
		}
		return false;
	}
};

bool isSame(Cube &cube_one, Cube &cube_two)
{
	if (cube_one.getL() == cube_two.getL() && cube_one.getW() == cube_two.getW() && cube_one.getH() == cube_two.getH())
	{
		return	true;
	}
	return false;
}

int main(int argc, char* argv[])
{
	Cube cube_one;
	cube_one.setL(10);
	cube_one.setW(10);
	cube_one.setH(10);
	cout << "该立方体的表面积为:" << cube_one.calculate_S() << endl;
	cout << "该立方体的体积为:" << cube_one.calculate_V() << endl;
	
	Cube cube_two;
	cube_two.setL(10);
	cube_two.setW(10);
	cube_two.setH(11);
	cout << "该立方体的表面积为:" << cube_two.calculate_S() << endl;
	cout << "该立方体的体积为:" << cube_two.calculate_V() << endl;
	
	bool issame = isSame(cube_one, cube_two);
	issame == 1 ? cout << "全局函数判断两个立方体相同" : cout << "全局函数判断两个立方体不相同";
	cout << endl;

	bool issameByClass = cube_one.isSameByClass(cube_two);
	issameByClass == 1 ? cout << "成员函数判断两个立方体相同" : cout << "成员函数判断两个立方体不相同";
	cout << endl;
}

案例：判断点和圆的关系(在一个类中将另一个类作为成员，将不同的类拆成不同的文件)

#include 
#include 

using namespace std;

class Point
{
private:
	double point_X;
	double point_Y;
public:
	void set_X(double x)
	{
		point_X = x;
	}
	double get_X()
	{
		return point_X;
	}
	void set_Y(double y)
	{
		point_Y = y;
	}
	double get_Y()
	{
		return point_Y;
	}
};

class Circle
{
private:
	Point circleCenter;
	double circleR;
public:
	void setR(double r)
	{
		circleR = r;
	}
	double getR()
	{
		return circleR;
	}
	void setCircleCentre(Point p)
	{
		circleCenter = p;
	}
	Point getCircleCentre()
	{
		return circleCenter;
	}
};

void isInCircle(Circle c, Point p)
{
	double distance;
	distance = sqrt(pow(c.getCircleCentre().get_X() - p.get_X(), 2) + pow(c.getCircleCentre().get_Y() - p.get_Y(), 2));
	if (distance == c.getR())
	{
		cout << "点在圆上" << endl;
	}
	else if (distance < c.getR())
	{
		cout << "点在圆内" << endl;
	}
	else
	{
		cout << "点在圆外" << endl;
	}
}

int main(int argc, char* argv[])
{
	Point p;
	p.set_X(10);
	p.set_Y(11);

	Point centre;
	centre.set_X(10);
	centre.set_Y(0);
	Circle circle;
	circle.setCircleCentre(centre);
	circle.setR(10);

	isInCircle(circle, p);
	return 0;
}

如何把不同的类写入不同的文件

在头文件中创建一个point.h,源文件中创建一个point.cpp

point.h

#pragma once
#include 

using namespace std;

class Point
{
private:
	double point_X;
	double point_Y;
public:
	void set_X(double x);

	double get_X();

	void set_Y(double y);

	double get_Y();

};

point.cpp

#include "point.h"

void Point::set_X(double x)
{
	point_X = x;
}
double Point::get_X()
{
	return point_X;
}
void Point::set_Y(double y)
{
	point_Y = y;
}
double Point::get_Y()
{
	return point_Y;
}

在头文件中创建一个circle.h,源文件中创建一个circle.cpp

circle.h

#pragma once
#include 
#include "point.h"

using namespace std;

class Circle
{
private:
	Point circleCenter;
	double circleR;
public:
	void setR(double r);
	
	double getR();

	void setCircleCentre(Point p);
	
	Point getCircleCentre();
};

circle.cpp

#include "circle.h"

void Circle::setR(double r)
{
	circleR = r;
}
double Circle::getR()
{
	return circleR;
}
void Circle::setCircleCentre(Point p)
{
	circleCenter = p;
}
Point Circle::getCircleCentre()
{
	return circleCenter;
}

main.cpp

#include 
#include 
#include "circle.h"
#include "point.h"

using namespace std;

void isInCircle(Circle c, Point p)
{
	double distance;
	distance = sqrt(pow(c.getCircleCentre().get_X() - p.get_X(), 2) + pow(c.getCircleCentre().get_Y() - p.get_Y(), 2));
	if (distance == c.getR())
	{
		cout << "点在圆上" << endl;
	}
	else if (distance < c.getR())
	{
		cout << "点在圆内" << endl;
	}
	else
	{
		cout << "点在圆外" << endl;
	}
}

int main(int argc, char* argv[])
{
	Point p;
	p.set_X(10);
	p.set_Y(9);

	Point centre;
	centre.set_X(10);
	centre.set_Y(0);
	Circle circle;
	circle.setCircleCentre(centre);
	circle.setR(10);

	isInCircle(circle, p);
	return 0;
}