c++ 类和对象-封装2

访问权限

#include<iostream>
#include<string>
using namespace std;
//访问权限
//三种
//公共权限 public       成员 类内可以访问  类外可以访问
//保护权限 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 = 123456;
	}
};
int main(){
	//实例化具体对象
	person p1;
	p1.m_name = "李四";
	//p1.m_car = "奔驰";  //保护权限内容，在类外访问不到
	//p1.m_password = 123;//私有权限内容，在类外访问不到
	p1.func();
	return 0;
}

struct和class的区别：

唯一区别：访问权限不同

struct默认访问权限为公有

class默认访问权限为私有

#include<iostream>
#include<string>
using namespace std;
class C1{
	int m_a;//默认权限 是私有
};
struct C2{
	int m_a;//默认权限 是公有
};
int main(){
	//struct 和 class区别
	//struct 默认权限是 公有 public
	//class  默认权限是 私有 private
	C1 c1;
	//c1.m_a = 100;//在class里默认权限 私有，因此类外不可以访问
	C2 c2;
	c2.m_a = 100;//在struct默认权限 公有，因此类外可以访问
	return 0;
}

成员属性设置为私有

在class里公有的用函数访问私有的不用在赋值的时候加上string

#include<iostream>
#include<string>
using namespace std;
//成员属性设置私有
//1、可以自己控制读写权限
//2、对于写可以检测数据有效性
//人类
class person{
public:
	//设置姓名
	void setname(string name){
		m_name = name;
	}
	//获取姓名
	string getname(){
		return m_name;
	}
	//获取年龄
	int getage(){
		return m_age;
	}
	//设置偶像
	void setidol(string idol){
		m_idol = idol;
	}
private:
	string m_name;//姓名 可读可写
	int m_age = 18;//年龄 只读
	string m_idol;//偶像 只写
};
int main(){
	person p;
	//姓名设置
	p.setname("张三");
	//获取姓名
	cout<<"姓名："<<p.getname()<<endl;
	//年龄设置
	p.getage();
	//p.setage(20);会报错
	//获取年龄
	cout<<"年龄："<<p.getage()<<endl;
	//偶像设置
	p.setidol("小明");
	//cout<<"偶像："<<p.getidol()<<endl;//只写状态 外界访问不到
	return 0;
}

年龄检测数据有效性

#include<iostream>
#include<string>
using namespace std;
//成员属性设置私有
//1、可以自己控制读写权限
//2、对于写可以检测数据有效性
//人类
class person{
public:
	//获取年龄
	int getage(){
		return m_age;
	}
	void setage(int age){
		if(age > 150 || age < 0){
			cout<<"年龄输入有误"<<endl;
			return;
		}
		m_age = age;
	}
private:
	int m_age = 18;//年龄 只读  也可以写（年龄必须在 0 ~ 150 之间）
};
int main(){
	person p;
	//年龄设置
	p.setage(20);
	p.getage();
	//获取年龄
	cout<<"年龄："<<p.getage()<<endl;
	return 0;
}

案例一：判断两个立方体是否相等

?? ? ? ? ? ? ?利用全局函数和成员函数判断

#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;
	}else{
		return false;
	}
}
int main(){
	//创建立方体对象
	cube c1;
	c1.setl(10);
	c1.setw(10);
	c1.seth(10);
	//600
	cout<<"c1的面积为："<<c1.calculates()<<endl;
	//1000
	cout<<"c1的体积为："<<c1.calculatev()<<endl;
	//创建第二个立方体
	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;
	}
	//利用成员函数判断
	ret = c1.issamebyclass(c2);
	if(ret){
		cout<<"成员函数判断：c1和c2是相等的"<<endl;
	}
	else{
		cout<<"成员函数判断：c1和c2是不相等的"<<endl;
	}
	return 0;
}

案例二：设计一个圆类和一个点类，判断点和圆的关系

#include<iostream>
#include<string>
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;
	//在类中可以让另一个类 作为本类中的成员
	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);
	//创建点
	point p;
	p.setx(10);
	p.sety(11);
	isincircle(c,p);
	return 0;
}

实际开发中不可能包含在一个文件中，拆成多个文件：

.h文件中包含#pragma once防止头文件重复包含

.cpp文件中包含对应的头文件即可

main.cpp:

#include<iostream>
#include<string>
#include "circle.h"
#include "point.h"
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;
	//在类中可以让另一个类 作为本类中的成员
	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);
	//创建点
	point p;
	p.setx(10);
	p.sety(11);
	isincircle(c,p);
	return 0;
}

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"
//点类
//setx、getx都是成员函数，所以要加上point作用于下的成员函数
//shift + tab键   整体缩进
//设置x
void point::setx(int x){
	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;
}

circlr.h:

#pragma once
#include<iostream>
#include "point.h"
using namespace std;
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;
}