C++类和对象(1)：封装--权限用法(private/public/protected)、class与struct的区别

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

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

封装——C++面向对象三大特性之一；

封装意义：

• 将属性和行为作为一个整体，表现生活中的事物；
• 将属性和行为加以权限控制；

封装的意义一：

• 在设计类的时候，属性和行为写在一起，表现事物；
• 语法：class 类名 { 访问权限 ： 属性 / 行为 }
  示例：设计一个圆类，求圆的周长：

注意：写代码要先写思路，然后再开始写代码)

//圆周率
const double PI = 3.14;

//设计一个圆类，求圆的周长——圆求周长公式：2*PI*半径
//class代表设计一个类，类后面紧跟着的就是类的名称;
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;


	system("pause");	//暂停一下以便查看
	return 0;	//标准的返回退出
 }

也可以通过成员函数来给成员变量赋值：

class Student
{
public:
	string name;
	int ID;
	void display() {
		cout << "学号：" << this->ID << ";姓名为：" << this->name<<endl;
	}
	void setName(string N) {
		name = N;
	}
	void setId(int id) {
		ID = id;
	}
};
int main() {
	Student s1;
	//s1.ID = 12;
	s1.setId(13);
	//s1.name = "王五";
	s1.setName("小王");
	s1.display();

	system("pause");	//暂停一下以便查看
	return 0;	//标准的返回退出
 }

类中的属性和行为：我们统一称为成员：
属性：称为成员属性或成员变量；
行为：称为成员函数或成员方法；

封装的意义二：

• 类在设计时，可以把属性和行为放在不同的权限下，加一控制；
  访问权限有3种：
  1.public——公共权限：类内可以访问，类外也可以访问
  2.protected——保护权限：类内可以访问，类外不可以访问
  3.private——私有权限：类内可以访问，类外不可以访问

保护权限与私有权限的区别：
保护权限：protected:儿子可以访问父亲中的保护内容；
私有权限：private儿子不可以访问父亲的私有内容；

class Person {
public://公共权限
	string m_name;
protected://保护权限
	string m_car;
private://私有权限
	int m_password;	//银行卡密码
public:
	void func(){
在类内，无论是什么权限都可以进行访问
		m_name = "张三";
		m_car = "宝马";
		m_password = "123";
	}
};
int main() {
	Person p1;
	p1.m_name = "李四";
保护权限和私有权限都不可以在类外进行访问
	//p1.m_car = "奔驰";
	//p1.password = "222";

	system("pause");	//暂停一下以便查看
	return 0;	//标准的返回退出
 }

struct和class的区别：

• struct和class都可以用来表示并创建类；
• 在C++中struct和class唯一的区别就是在于默认的访问权限不同：
• 区别：
• struct默认权限为公共；——公共权限：public
• class默认为私有；——私有权限：private

class Student {
	默认权限为私有权限——private
	string name;
};
struct Stu {
	默认权限为公共权限——public
	string name;
};

int main() {
	Student s1;
	//s1.name;——无法访问
	Stu s2;
	s2.name;

	system("pause");	//暂停一下以便查看
	return 0;	//标准的返回退出
 }

将成员属性设置为私有：

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

class Person {
private:
1.可以自己设置读写权限
	//可读可写
	string name;
	//只写
	int age;
public:
姓名设置可读可写；
	void setName(string c_name) {
		name = c_name;
	}
	string getName() {
		return name;
	}
2.可以检测数据的有效性
	void setAge(int c_age) {
		if (c_age < 0 || c_age>150) {
			age = 0;
			cout << "输入有误";
			return;
		}
		age = c_age;
	}
	int getAge() {
		return age;
	}
};
int main() {
	Person p1;
	//无法访问私有成员:可自己控制读写权限
	//p1.name;
	p1.setName("张三");
	cout << "p1的名字为：" << p1.getName()<<endl;

	system("pause");	//暂停一下以便查看
	return 0;	//标准的返回退出
 }

注：有时传入形参的目的单纯是为了单纯的进行比较或者修改值

这时可以用C++特有的传引用“&”——来进行传递形参；

这样就不用单独给形参开辟空间，节省时间

class Square {
private:
	int s_C;
	int s_K;
public:
	void setC(int x_C) {
		s_C = x_C;
	}
	int getC() {
		return s_C;
	}
	void setK(int x_K) {
		s_K = x_K;
	}
	int getK() {
		return s_K;
	}
利用成员函数对两个长方形进行比较——这是只需要传入另一个实例
	bool compareSquare(Square &x_s) {
		if (s_C == x_s.s_C&&s_K == x_s.s_K) {
			return true;
		}
			return false;
	}
};
利用全局函数对两个长方形进行比较：————传入两个实例
bool compareSquare(Square &s1, Square &s2) {
	if (s1.getC() == s2.getC() &&s1.getK() == s2.getK() ){
		return true;
	}
		return false;
}
int main() {
	Square q1, q2;
	q1.setC(10);
	q1.setK(20);
	q2.setC(10);
	q2.setK(10);
	if (q1.compareSquare(q2)) {
		cout << "两个长方形相等；";
	}
	else
	{
		cout << "两个长方形不相等";
	}
	system("pause");	//暂停一下以便查看
	return 0;	//标准的返回退出
 }

对于一个复杂的大项目，模块化编写程序，便于理解，且容易下手，将问题分解成一小块一小块，逐个击破：

方便代码管理：(我们可以创建3个文件)

• 1.建立.h头文件(进行变量与函数的声明)
• 2.建立.cpp文件(对.h头文件中声明的函数进行实现/定义)
• 3.建立main.cpp文件(对声明,定义的函数进行调用)
  抽象一个点，一个圆，并判断点与圆的关系。（在圆内还是圆外）
  h文件进行类的声明；
  cpp文件为类的实现细节；主要注重的细节为：
  

注意：
> 1…h头文件中主要放函数/变量的声明；——可以加入一些库函数(比如#include等，因为后期主要是将整个.h头文件引用到.cpp实现函数文件和main.cpp主调用文件中)
2…cpp定义/实现函数文件中；需要包含头文件；(如上述代码中包含#include"point.h")
3.主main.cpp实现文件中，也需要包含头文件：（如上述代码中需要包含：#include “circle.h”
#include “point.h”）

• 注意：
• .cpp实现函数文件中要使用域作用符：
  
  在类外定义成员函数；
  使用域作用符；