【C++核心编程】4.1类和对象：封装

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

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

例如：人可以作为对象，属性有姓名、年龄、身高、体重等，行为有走、跑、跳、吃饭、唱歌等；车也可以作为对象，属性有轮胎、方向盘、车灯等，行为有载人、放音乐、放空调等。
具有相同性质的对象，可以抽象为类。

一、封装

1、封装的意义

1.1 将属性和行为作为一个整体，表现生活中的事物。
在设计类的时候，属性和行为写在一起，表现事物。语法为：class 类名 { 访问权限: 属性 / 行为};属性一般用变量表示，行为一般用函数表示。注意：访问权限后面是冒号！！！

通过一个类来创建一个对象的过程就叫实例化。
类中的属性和行为统称为成员。
属性也称为成员属性、成员变量。
类中的行为也成为成员函数、成员方法。

const double PI = 3.14;//圆周率

//设计一个圆类，求圆的周长 2 * PI * 半径
class Circle
{
	//访问权限
public://公共权限
	//属性
	int m_r; //半径
	//行为（通常用函数来定义）:获取圆的周长
	double calculateZC()
	{
		return 2 * PI * m_r;
	}
};

int main()
{
	//通过圆类创建具体的圆（对象）
	Circle c1;
	//给圆对象的属性进行赋值
	c1.m_r = 10;

	cout << "圆的周长为：" << c1.calculateZC() << endl;//62.8

	system("pause");
	return 0;
}

也可以通过行为向属性赋值：

//设计一个圆类
class Circle
{
	//访问权限
public://公共权限
	//属性
	int m_r; //半径
	//行为
	void setR(int r)
	{
		m_r = r;
	}
};

int main()
{
	Circle c1;
	c1.setR(10);

	cout << "圆的半径为：" << c1.m_r << endl;

	system("pause");
	return 0;
}

1.2 将属性和行为加以权限控制
类在设计时，可以把属性和行为放在不同的权限下，加以控制。
访问权限有三种：

• public公共权限：类内、类外都可以访问
• protected保护权限：类内可以访问，类外不可以访问，继承可以访问
• private私有权限：类内可以访问，类外不可以访问，继承不可以访问

2、struct和class的区别

在C++中struct和class唯一的区别就在于默认的访问权限不同。
struct默认权限为公共public；
class默认权限为私有private。

3、成员属性设置为私有

优点1：将所有成员属性设置为私有，可以自己控制读写权限；
优点2：对于写权限，可以检测数据的有效性。

class Person
{
public:
	//写姓名，即设置姓名
	void setName(string name)
	{
		m_Name = name;
	}
	//读姓名，即获取姓名
	string getName()
	{
		return m_Name;
	}
	
	//获取年龄
	int getAge()
	{
		m_Age = 10; //初始化为10岁
		return m_Age;//若没有初始化，直接return，将会出现乱码
	}

	//设置年龄
	void setAge(int age)
	{
		if (age < 0|| age > 150)
		{
			cout << "输入有误！" << endl;
			return;
		}
		m_Age = age;
	}

	//设置情人
	void setLover(string lover)
	{
		m_Lover = lover;
	}

private:
	string m_Name;//姓名，设置为可读可写
	int m_Age;//年龄，设置为可读可写，但年龄的范围必须是0-150
	string m_Lover;//情人，设置为只写
};

int main()
{
	Person p;
	p.setName("张三");
	cout << "姓名为：" << p.getName() << endl;
	p.setAge(18);
	cout << "年龄为：" << p.getAge() << endl;
	p.setLover("苍井");
	//此处无法输出情人姓名，无法输出

	system("pause");
	return 0;
}

4、案例

案例1：设计立方体类Cube。求出立方体的面积和体积，分别用全局函数和成员函数判断两个立方体是否相等。

#include<iostream>
#include<string>
using namespace std;

//1、创建立方体类
//2、设计属性
//3、设计行为：获取立方体面积和体积
//4、分别利用全局函数和成员函数判断两个立方体是否相等
class Cube
{
public:
	void setL(int l)//设置长
	{
		m_L = l;
	}
	int getL()//获取长
	{
		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;
	}

	//利用成员函数判断两个立方体是否相等
	bool isSameByClass(Cube &c)//只传一个参数就可以了！！！！
	{
		if (m_L == c.getL() && 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.getL() == c2.getL() && 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;//600
	cout << "c1的体积为： " << c1.calculateV() << endl;//1000

	//创建第二个立方体
	Cube c2;
	c2.setL(10);
	c2.setW(10);
	c2.setH(10);

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

	//利用成员函数判断
	bool ret1 = c1.isSameByClass(c2);
	if (ret1)
	{
		cout << "成员函数判断：c1和c2是相等的" << endl;
	}
	else
	{
		cout << "成员函数判断：c1和c2是不相等的" << endl;
	}

	system("pause");
	return 0;
}

案例2：设计一个圆形类Circle和一个点类Point，计算点和圆的关系。

总结：在类中可以让另一个类作为本类中的成员。

分文件编写如下
可以通过在头文件中创建一个point.h文件：

#pragma once//防止头文件重复包含
#include<iostream>
using namespace std;
class Point
{
public:
	//设置x
	void setX(int x);
	//获取x
	int getX();
	//设置y
	void setY(int y);
	//获取y
	int getY();
private:
	int m_X;
	int m_Y;
};

源文件point.cpp中：

#include "point.h"

//设置x
void Point::setX(int x)//Point作用域下的setX()函数，加了::此时由全局函数变为成员函数
{
	m_X = x;
}
//获取x
int Point::getX()
{
	return m_X;
}
//设置y
void Point::setY(int y)
{
	m_Y = y;
}
//获取y
int Point::getY()
{
	return m_Y;
}

头文件circle.h：

#pragma once
#include<iostream>
using namespace std;
#include "point.h"

class Circle
{
public:
	//设置半径
	void setR(int r);
	//获取半径
	int getR();
	//设置圆心
	void setCenter(Point center);
	//获取圆心
	Point getCenter();
private:
	int m_R;//半径
	Point m_Center;//圆心
};

源文件circle.cpp：

#include "circle.h"

//设置半径
void Circle::setR(int r)
{
	m_R = r;
}
//获取半径
int Circle::getR()
{
	return m_R;
}
//设置圆心
void Circle::setCenter(Point center)
{
	m_Center = center;
}
//获取圆心
Point Circle::getCenter()
{
	return m_Center;
}

在另一个cpp文件中包含main()函数如下：

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

//判断点和圆的关系
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);
	//创建点
	Point p;
	p.setX(10);
	p.setY(10);
	//判断关系
	isInCircle(c, p);

	system("pause");
	return 0;
}

【未完待续】