C++核心编程学习笔记之【类和对象之封装】（十二）

类和对象

c++面向对象的三大特性为：封装、继承、多态
c++热门为万事万物都皆为对象，对象有其属性和行为。属性和行为又统一称为成员

封装

1、封装的意义

1.1 封装的意义（一）

#include
using namespace std;
#include  //使用string字符

//圆周率
const double PI= 3.14;
//设计一个圆类，并求周长
//周长的公式：2*PI*半径
//class代表设计一个类，类后面紧跟着就是类的名称
class Circle
{
	//访问权限
	//公共权限
public:
	//属性
	//半径
	int m_r;

	//行为
	//获取圆的周长
	double cal_perimeter()
	{
		return 2 * PI * m_r;
	}
};

int main() {
	//通过圆类创建具体的圆（对象）
	//实例化：通过一个类创建一个对象的过程
	Circle c1;
	//给圆对象的属性进行赋值
	c1.m_r = 10;
	//计算圆的周长
	cout << "周长：" << c1.cal_perimeter() << endl;

	system("pause");
	return 0;
}

输出：

周长：62.8
请按任意键继续. . .

1.1.1 案例练习

补充：
属性和行为又统一称为成员，
属性又称为成员属性或成员变量，
行为又称为成员函数或成员方法，

#include
using namespace std;
#include  //使用string字符

class Student
{
	//访问权限
public://公共权限
	//属性
	string s_name;
	int ID;

	//打印学生信息
	void show_info()
	{
		cout << "name:" << s_name << ", ID:" << ID << endl;
	}

	//给姓名赋值
	void set_name(string name)
	{
		s_name = name;
	}
};

int main() {
	//实例化学生对象
	Student s1;
	//给学生对象赋值
	//s1.name = "王五";
	s1.set_name("王五");
	s1.ID = 01;
	//打印学生信息
	s1.show_info();

	system("pause");
	return 0;
}

输出：

name:王五, ID:1
请按任意键继续. . .

1.2 封装的意义（二）

类在设计时，可以把属性和行为放在不同的权限下，加以控制
访问权限有三种：
1、public 公共权限：成员类内可以访问，类外也可以访问；
2、protected 保护权限：成员类内可以访问，类外不可以访问；
儿子可以访问父亲中的保护内容；
3、private 私有权限：成员类内可以访问，类外不可以访问；
儿子不可以访问父亲中的私有内容；

#include
using namespace std;
#include  //使用string字符

class Person
{
	//1、public 公共权限：成员类内可以访问，类外也可以访问；
public:
	string p_Name;
	//2、protected 保护权限：成员类内可以访问，类外不可以访问；儿子可以访问父亲中的保护内容；
protected:
	string p_Car;
	//3、private 私有权限：成员类内可以访问，类外不可以访问；儿子不可以访问父亲中的私有内容；
private:
	int p_Password;
public:
	void func()
	{
		p_Name = "张三";
		p_Car = "bmw";
		p_Password = 123456;
	}
};

int main() {
	//实例化具体对象
	Person p1;
	p1.p_Name = "李四";
	p1.p_Car = "benci";//保护权限内容在类外访问不到
	p1.p_Password = 123;//私有权限内容在类外访问不到

	system("pause");
	return 0;
}

2、struct和class的区别

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

#include
using namespace std;
#include  //使用string字符

class C1
{
	int id;//默认权限是私有
};

struct S1
{
	int id;//默认权限是公共
};

int main() {
	C1 c1;
	c1.id = 123;//报错 默认权限是私有

	S1 s1;
	s1.id = 123;

	system("pause");//正确 默认权限是公共
	return 0;
}

3、成员属性设置为私有

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

#include
using namespace std;
#include  //使用string字符

//成员属性设置为私有
//设计人类
class Person
{
public:
	//写姓名
	void set_name(string name)
	{
		p_name = name;
	}
	//读姓名
	string get_name()
	{
		return p_name;
	}

	//读年龄
	int get_age()
	{
		//p_age = 0;
		return p_age;
	}
	//写年龄
	void set_age(int age)
	{
		if (age<0||age>150)
		{
			p_age = 0;
			cout << "你这个老妖精！" << endl;
		}
		p_age = age;
	}

	//写情人
	void set_lover(string lover)
	{
		p_lover = lover;
	}

private:
	//姓名 可读可写
	string p_name;

	//年龄 只读
	int p_age;
	//情人 只写
	string p_lover;

};

int main() {
	Person p1;
	p1.set_name("张三");
	cout << p1.get_name() << endl;

	p1.set_age(1000);
	cout << p1.get_age() << endl;

	p1.set_lover("西施");//不可以访问

	system("pause");//正确 默认权限是公共
	return 0;
}

输出：

张三
你这个老妖精！
0
请按任意键继续. . .

4、封装案例（一）

#include
using namespace std;
#include  //使用string字符

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

class Cude
{
public:
	//设置立方体的长、宽、高
	//void set_data(int length, int weight, int high)
	//{
	//  c_length = length;
	//	c_weight = weight;
	//	c_high = high;
	//}
	void set_length(int length)
	{
		c_length = length;
	}
	void set_weight(int weight)
	{
		c_weight = weight;
	}
	void set_high(int high)
	{
		c_high = high;
	}
	//int get_data()
	//{
	//	return c_length, c_weight, c_high;
	//}
	//获取长度
	int get_length()
	{
		return c_length;
	}
	//获取高度
	int get_high()
	{
		return c_high;
	}
	//获取宽度
	int get_weight()
	{
		return c_weight;
	}
	//计算体积
	int cal_v()
	{
		return c_length * c_weight * c_high;
	}
	//计算面积
	int cal_area()
	{
		return (c_length * c_weight + c_weight * c_high + c_length * c_high) * 2;
	}
	//利用成员函数判断两个立方体是否相等
	bool isSamebyclass(Cude &c)
	{
		if (c_length == c.get_length() && c_weight == c.get_weight() && c_high == c.get_high())
		{
			return true;
		}
		return false;
	}
private:
	int c_length;//长
	int c_weight;//宽
	int c_high;//高
};

//利用全局函数判断两个立方体是否相等
bool isSame(Cude &c1, Cude &c2)
{
	if (c1.get_length() == c2.get_length() && c1.get_weight() == c2.get_weight() && c1.get_high() == c2.get_high())
	{
		return true;
	}
	return false;
}

int main() {
	//创建第一个立方体对象
	Cude c1;
	//c1.set_data(10, 10, 10);
	c1.set_length(10);
	c1.set_weight(10);
	c1.set_high(10);
	cout << c1.cal_area() << endl;
	cout << c1.cal_v() << endl;
	//创建第二个立方体对象
	Cude c2;
	//c2.set_data(10, 10, 10);
	c2.set_length(10);
	c2.set_weight(10);
	c2.set_high(11);
	//全局函数判断两个立方体是否相等
	bool res = isSame(c1, c2);
	if (res == true)
	{
		cout << "两个立方体相等" << endl;
	}
	else 
	{
		cout << "两个立方体不相等" << endl;
	}
	//成员函数判断两个立方体是否相等
	bool res2 = c1.isSamebyclass(c2);
	if (res == true)
	{
		cout << "成员函数判断:两个立方体相等" << endl;
	}
	else
	{
		cout << "成员函数判断:两个立方体不相等" << endl;
	}

	system("pause");
	return 0;
}

输出：

600
1000
两个立方体不相等
成员函数判断:两个立方体不相等
请按任意键继续. . .

5、封装案例（二）

#include
using namespace std;
#include  //使用string字符

//点和圆关系案例
// 点类
class pointer 
{
public:
	//设置x指标
	void set_x(int x)
	{
		m_x = x;
	}
	//设置y坐标
	void set_y(int y)
	{
		m_y = y;
	}
	//获取x坐标
	int get_x()
	{
		return m_x;
	}
	//获取y坐标
	int get_y()
	{
		return m_y;
	}
private:
	int m_x;
	int m_y;
};

//圆类
class circle
{
public:
	//设置半径
	void set_r(int r)
	{
		m_r = r;
	}
	//获取半径
	int get_r()
	{
		return m_r;
	}
	//设置圆心
	void set_center(pointer center)
	{
		m_center = center;
	}
	//获取圆心
	pointer get_center()
	{
		return m_center;
	}
private:
	int m_r;//半径
	//在类中，可以让另一个类作为本类中的成员
	pointer m_center;//圆心
};

//判断点和圆的关系
void isIncircle(circle& c, pointer& p)
{
	//计算两点之间距离的平方
	int distance=
	(c.get_center().get_x() - p.get_x())* (c.get_center().get_x() - p.get_x())
		+ (c.get_center().get_y() - p.get_y()) * (c.get_center().get_y() - p.get_y());
	//计算半径的平方
	int r_distance = c.get_r() * c.get_r();
	//判断关系
	if (distance == r_distance)
	{
		cout << "点在圆上" << endl;
	}
	else if (distance > r_distance)
	{
		cout << "点在圆外" << endl;
	}
	else
	{
		cout << "点在圆内" << endl;
	}
}

int main() {
	//创建圆对象
	circle c;
	pointer center;
	center.set_x(10);
	center.set_y(0);
	c.set_center(center);
	c.set_r(10);
	//创建点
	pointer p;
	p.set_x(10);
	p.set_y(10);
	//判断关系
	isIncircle(c, p);

	system("pause");
	return 0;
}

输出：

点在圆上
请按任意键继续. . .

将上述代码进行分文件编写：
我们把上面代码中的圆类和点类写入头文件和源文件中；
1、先创建如图的.h和.cpp文件；

2、下面就怎样把点类写入头文件和源文件做讲解，圆类就此忽略；
先在point.h文件中，把点类成员方法里面的函数体语句删除；如下
注意在代码前写入：#pragma once//防止头文件重复包含

#pragma once//防止头文件重复包含
#include
using namespace std;

// 点类,把声明去掉
class pointer
{
public:
	//设置x指标
	void set_x(int x);
	
	//设置y坐标
	void set_y(int y);
	
	//获取x坐标
	int get_x();
	
	//获取y坐标
	int get_y();
	
private:
	int m_x;
	int m_y;
};

3、接着在point.cpp中，只写入点类的成员方法，如下：
注意：
1、因为m_x、m_y 是在原类中的，所以在前面应包含point.h文件；
2、在每一个成员方法前面加一个作用域 pointer:: ；

#include "point.h"

// 点类


//设置x指标
//为什么加pointer？
//答：下面的函数实际都是成员函数，是在pointer类里面的，pointer作用域
void pointer::set_x(int x)
{
	m_x = x;
}
//设置y坐标
void pointer::set_y(int y)
{
	m_y = y;
}
//获取x坐标
int pointer::get_x()
{
	return m_x;
}
//获取y坐标
int pointer::get_y()
{
	return m_y;
}

4、在main主函数的前面再加上2个类头文件即可；

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