C++基础（13）——函数高级用法:封装

目录1.封装的意义

1.1封装的意义一：

 1.2 封装的意义二

 2.struct和class区别

 3.成员属性私有化

4.示例1

5.示例2

1.封装的意义

• 封装是C++面向对象三大特征之一
• 将属性和行为作为一个整体，表现生活中的事物
• 将属性和行为加以权限控制

1.1封装的意义一：

将属性和行为作为一个整体，表现生活中的事物

语法：class 类名{访问权限：属性/行为};

专业术语：

• 类中的属性和行为统一称为成员，类中的属性称为成员属性和成员变量
• 类中的行为成为成员方法或成员函数

示例1：设计一个圆类，求圆的周长

#include<iostream>
using namespace std;
const double PI = 3.14;

//设计一个圆类，求圆的周长
//class代表一个类，类后面是类名
class Circle{
	//访问权限
	//公共权限：会让行为或者属性不管在类内还是类外都可以访问
public:
	//属性
	int m_r;//半径
	//行为
	//获取圆的周长
	double calcalateZC() {
		return 2 * PI * m_r;
	}
};
int main() {
	//通过圆类来创建具体的圆（对象）
	Circle cl;//通过一个类创建一个对象
	//给圆的对象的属性赋值
	cl.m_r = 10;
	cout << "圆的周长为：" << cl.calcalateZC() << endl;

	return 0;
}

示例2.设计一个学生类，属性有姓名和学号，可以给姓名和学号赋值，可以显示学生的姓名和学号

#include<iostream>
using namespace std;

class Student {
public:
	string name;
	string stuID;

	void showStudent() {
		cout << "学生姓名：" << name << endl;
		cout << "学生编号：" << stuID << endl;
	}
};
int main() {
	Student stu;
	stu.name = "张三";
	stu.stuID = "123456";
	stu.showStudent();

	return 0;
}

我们也可以通过如下的方式对学生名字进行赋值：

 1.2 封装的意义二

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

访问权限有三种：

• public 公共权限：成员类内可以访问，类外可以访问
• protected 保护权限：类内可以访问，类外不可以访问，父类的私有权限子类也可以访问
• private 私有权限：类内可以访问，类外不可以访问，父类的私有权限子类不可以访问

#include<iostream>
using namespace std;

class Person {
public:
	string m_name;

protected:
	string m_car;
private:
	int m_password;//银行卡密码

public:
	void func() {
		m_name = "张三";
		m_car = "拖拉机";
		m_password = 1234560;
	}
};
int main() {
	Person p1;
	p1.m_name = "李四";
	//p1.m_car = "奔驰";//保护权限的内容在类外不能访问,私有权限的内容同样不能
	return 0;
}

 2.struct和class区别

在c++中struct和class都用来创建一个类，唯一的区别就在于默认的访问权限不同

区别：

• struct默认权限为公共
• class默认的权限为私有

发现C1报错。C2正常。

 3.成员属性私有化

优点：

• 将所有成员属性设置为私有，可以自己控制读写权限
• 对于写权限，我们可以检测数据的有效性

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

#include<iostream>
using namespace std;

class Person{
private://由于都是私有的属性，在类外不能访问，所以我们需要给他一些public权限作为类内和类外的接口
	string m_name;//设置为可读可写
	int m_age;//设置为只读
	string m_lover;//设置为只写

public://有这个接口这样外层就可以调用下面函数对名字进行读写
	//设置姓名-写
	void setName(string name) {
		m_name = name;
	}
	//获取姓名-读
	string getName() {
		return m_name;
	}
	//年龄是只读，只需获取即可
	int getAge() {
		m_age = 0;//初始化为0
		return m_age;
	}
	//m_lover只写
	void setLover(string lover) {
		m_lover = lover;
	}

};

int main() {
	Person p1;
	p1.setName("张三");
	cout <<"姓名为：" << p1.getName() << endl;
	cout << "年龄为：" << p1.getAge() << endl;
	p1.setLover("苍进空");
	//如果要访问是不能的。因为权限只能写，外层不能访问
	//cout << "情人为：" << p1.m_lover << endl;报错

	return 0;
}

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

#include<iostream>
using namespace std;

class Person{
private://由于都是私有的属性，在类外不能访问，所以我们需要给他一些public权限作为类内和类外的接口
	string m_name;//设置为可读可写
	int m_age;//设置为只读
	string m_lover;//设置为只写

public://有这个接口这样外层就可以调用下面函数对名字进行读写
	//设置姓名-写
	void setName(string name) {
		m_name = name;
	}
	//获取姓名-读
	string getName() {
		return m_name;
	}
	//年龄是 可读可写，如果想要修改年龄的范围必须是0-150之间
	int getAge() {
		return m_age;
	}
	void setAge(int age) {
		if (age < 0 || age>150) {
			m_age = 0;//输入错误强制改为0岁
			cout << "输入的年龄有误" << endl;
			return;//输入有误直接return退出即可
		}
		m_age = age;
	}

	//m_lover只写
	void setLover(string lover) {
		m_lover = lover;
	}

};

int main() {
	Person p1;
	p1.setName("张三");
	cout <<"姓名为：" << p1.getName() << endl;

	p1.setAge(1000);//需要多数据的有效性进行验证，如果不符合就不再输入
	cout << "年龄为：" << p1.getAge() << endl;
	p1.setLover("苍进空");
	//如果要访问是不能的。因为权限只能写，外层不能访问
	//cout << "情人为：" << p1.m_lover << endl;报错

	return 0;
}

4.示例1

设计立方体类（cube）：

求出立方体的面积和体积，分别用全局函数和成员函数判断两个立方体是不是相等

立方体设计：

1. 创建立方体类
2. 设计属性
3. 设计行为，获取立方体面积和体积
4. 分别利用全局函数（写在类外）和成员函数（写在类内）判断两个立方体是否相同

#include<iostream>
using namespace std;

class Cube{
public://设置一个public接口
	//设置长
	void setL(int l) {
		m_L = l;
	}
	//获取长
	int get_L() {
		return m_L;
	}
	//设置宽
	void setW(int w) {
		m_W = w;
	}
	//获取宽
	int getW() {
		return m_W;
	}
	//设置高
	void setH(int h) {
		m_H = h;
	}
	//获取高
	int getH() {
		return m_H;
	}

	//获取立方体面积
	int calculateS() {
		return 2 * m_L * m_W + 2 * m_W * m_H + 2 * m_L * m_H;
	}

	//获取立方体体积
	int calculateV() {
		return m_L * m_W * m_H;
	}

	//利用成员函数判断两个立方体是否相同
	int isSameByClass(Cube& c) {//这里只需要传入一个参数就行，因为类里面本身已经有了一个类，现在还需要传入一个来进行对比
		if (m_L == c.get_L() && m_W == c.getW() && m_H == c.getH()) {
			return true;
		}
		return false;
	}

private://属性尽量都设置为私有，易于后面自己控制读写权限
	int m_L;
	int m_W;
	int m_H;
};

//利用全局函数判断两个立方体面积和体积是不是相同，两个立方体的长宽高都相同那么体积和面积也相同
bool isSame(Cube &c1,Cube &c2) {//引用的方式传递
	if (c1.get_L() == c2.get_L() && c1.getW() == c2.getW() && c1.getH() == c2.getH()) {
		return true;
	}
	return false;
}

int main() {
	Cube c1;
	c1.setL(10);
	c1.setW(10);
	c1.setH(10);

	cout << "C1的面积为：" << c1.calculateS() << endl;
	cout << "c1的体积为：" << c1.calculateV() << endl;

	Cube c2;
	c2.setL(10);
	c2.setW(10);
	c2.setH(10);

	//利用全局函数判断
	bool ret=isSame(c1, c2);
	if (ret) {//如果为true
		cout << "全局函数判断：c1和c2是相同的" << endl;
	}
	else {
		cout << "全局函数判断：c1和c2不相同" << endl;
	}

	//利用成员函数判断
	ret = c1.isSameByClass(c2);
	if (ret) {//如果为true
		cout << "成员函数判断：c1和c2是相同的" << endl;
	}
	else {
		cout << "成员函数判断：c1和c2不相同" << endl;
	}
	return 0;
}

5.示例2

点和圆的关系：

设计一个圆形类（Circle），和一个点类（Point）,计算点和圆的关系

点和圆关系的判断：

• 点到圆心的距离==半径  点在圆上
• 点到圆心的距离>半径   点在圆外
• 点到圆心的距离<半径   点在圆内

#include<iostream>
using namespace std;

//点类
class Point {
public:
	//设置x坐标
	void setX(int x) {
		m_X = x;
	}
	//获取x坐标
	int getX() {
		return m_X;
	}
	//设置y坐标
	void setY(int y) {
		m_Y = y;
	}
	//获取y坐标
	int getY() {
		return m_Y;
	}
private:
	int m_X;
	int m_Y;
};

//圆类
class Circle {
public:
	//设置半径
	void setR(int r) {
		m_R = r;
	}
	//获取半径
	int getR() {
		return m_R;
	}
	//设置圆心
	void setCenter(Point center) {//设置圆心我们要传入的是一个点
		m_center = center;
	}

	//获取圆心
	Point getCenter() {
		return m_center;
	}
private:
	int m_R;//半径
	/*对于圆心
	不要把他也当作两个类如下：
	int m_X;
	int m_Y;
	它本身就是一个整体，一个点，最好不要分开。我们可以设计一个点类如下：
	Point m_center;
    */
	Point m_center;//在类中可以将另一个类作为本类的成员
};


//判断点和圆的关系
void isInCircle(Circle& c, Point &p) {
	//计算两点之间距离平方
	int distance = (c.getCenter().getX() - p.getX()) * (c.getCenter().getX() - p.getX()) +
		(c.getCenter().getY() - p.getY()) * (c.getCenter().getY() - p.getY());
	//计算半径的平方
	int rdistance = c.getR()* c.getR();

	//判断关系
	if (distance == rdistance) {
		cout << "点在圆上" << endl;
	}
	else if (distance > rdistance) {
		cout << "点在圆外" << endl;
	}
	else {
		cout << "点在圆内" << endl;
	}
}

int main() {
	//创建圆
	Circle c;
	c.setR(10);
	Point center;//圆心
	center.setX(10);
	center.setY(0);
	c.setCenter(center);//把圆心的x,y坐标放进去
	
	//创建点
	Point p;
	p.setX(10);
	p.setY(10);

	//判断关系
	isInCircle(c, p);

	return 0;
}

 对于一个大的工程，许多类我们不可能都放在一个文件中，一般我们会把类拆分，例如在头文件中写他的声明，在 源文件中写实现。本案例我们可以拆分如下：

文件结构如下：

头文件写声明，源文件写实现。例如点类：

对于圆类如下：

测试文件为主文件，如下所示：

 测试结果：