一、面向对象的三大特性之封装

文笙子

已于 2024-03-15 21:13:31 修改

阅读量314

点赞数

分类专栏：未分类文章标签： c++ mfc 算法

于 2022-05-14 20:24:13 首次发布

本文链接：https://blog.csdn.net/weixin_43920777/article/details/124640052

版权

未分类专栏收录该内容

10 篇文章 0 订阅

订阅专栏

面向对象的三大特性之封装

C++认为万事万物皆为对象，对象上有其属性和行为。
封装的意义：
#将属性和行为作为一个整体，表现生活中的事物。
#将属性和行为加以权限控制

封装意义一

在设计类的时候，属性和行为写在一起，表现事物。
语法：class 类名 { 访问权限：属性 / 行为 }；

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

const double PI = 3.14;

//class 代表设计一个类，类后面紧跟着的就是类名称
class Circle
{
//访问权限，公共权限
public:
    //属性，半径
    int m_r;
    
    //行为，获取周长
    double zhouchang()
    {
        return 2 * PI * m_r;
    }
};

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

    cout << c1.zhouchang() << endl;
    return 0;
 }

案例二：设计一个学术类，属性有姓名和学号赋值，可以显示学生的姓名和学号。

class student
{
public:
	//行为
	string m_Name;
	int m_Id;

	//属性
	void showStudent()
	{
		cout << m_Name << endl;
		cout << m_Id << endl;
	}
};

int main()
{
	//实例化对象
	student s1;
	s1.m_Name = "张三";
	s1.m_Id = 123;

	s1.showStudent();

	return 0;
}

但是，除了这种方法赋值还有别的方法，我们可以通过这个函数也就是行为可以给属性赋值。
整体代码如下：

class student
{
public:
	//行为
	string m_Name;
	int m_Id;

	//属性
	void showStudent()
	{
		cout << m_Name << endl;
		cout << m_Id << endl;
	}

	void setName(string name)
	{
		m_Name = name;
	}

	void setId(int id)
	{
		m_Id = id;
	}
};

int main()
{
	//实例化对象
	student s1;
	s1.setName("张三");
	s1.setId(123);

	s1.showStudent();

	return 0;
}

专业术语小结：
1、类中的属性和行为我们统一称为成员
2、属性也称为成员属性和成员变量
3、行为也称为成员函数和成员方法

封装意义二

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

class Person
{
public:
	string m_Name;
protected:
	string m_Car;
private:
	int m_Password;

public:
	void func()
	{
		m_Name = "zhangsan";
		m_Car = "tulaji";
		m_Password = 123456;
	}
};

int main()
{
	Person p1;
	p1.m_Name = "lisi";
	
	return 0;
}

struct 和 class

思考一个问题？用户自定义类型，#struct和class有什么不同？
默认的访问权限不同。
struct默认权限为公有；
class默认权限为私有。

class a
{
	int m_A; //默认 私有
};

struct b
{
	int m_A; //默认 公有
};

int main()
{
	a c1;
	//c1.m_A = 100; //访问不了

	b c2;
	c2.m_A = 100;
	
	return 0;
}

成员属性设置为私有

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

class Person
{
public:
	void setName(string name) //姓名，可读可写
	{
		m_Name = name;
	}
	string getName()
	{
		return m_Name;
	}

	//获取年龄 可读可写 
	int getAge()
	{
		// m_Age = 0;
		return m_Age;
	}
	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; //只读 可写（这个写有限制条件）
	string m_Lover; //只写
};

int main()
{
	Person p;
	p.setName("张三");   
	cout << p.getName() << endl;
	
	p.setAge(18);
	cout << p.getAge() << endl;

	p.setLover("哈哈"); 
	//cout << p.setLover << endl; 只写

	return 0;
}

案例一：设计立方体类

求出立方体的面积和体积
分别用全局函数和成员函数判断两个立方体是否相等。
在这里插入图片描述
分析过程：
class Cude
{
public：
//行为
设置获取长宽高
获取立方体面积
获取立方体的行为
private：
//属性（所有的属性最好放在私有）
//长、宽、高
}

//立方体类设计
//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 S()
	{
		return 2 * m_L * m_W + 2 * m_W * m_H + 2 * m_L * m_H;
	}

	int V()
	{
		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.S() << endl;
	cout << c1.V() << endl;

	Cube c2;
	c2.setL(10);
	c2.setW(10);
	c2.setH(10);
	cout << c2.S() << endl;
	cout << c2.V() << endl;

	bool ret = isSame(c1, c2);
	if (ret) {
		cout << "相等" << endl;
	}
	else {
		cout << "不相等" << endl;
	}

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

	return 0;
}

案例二：点和圆的关系

设计一个圆形类（Circle)，和一个点lei(Point)，计算点和圆的关系。
`
分析：
点和圆心的距离 == 半径点在圆上
点和圆心的距离 > 半径点在圆外
点和圆心的距离 < 半径点在圆内

点到圆心的距离：？？？

(x1 - x2)^2 + (y1 - y2)^2

class Point
{
public:
	void setX(int x) 
	{
		m_X = x;
	}
	int getX()
	{
		return m_X;
	}

	void setY(int y)
	{
		m_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)
{
	//(x1 - x2)^2 + (y1 - y2)^2 计算两点之间距离 平方
	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);

	return 0;
}

两个要点：
1、在类中可以让另一个类作为本类的成员
2、后续代码多了之后，很多的类看着就很烦？？？So，拆开写

拆开点类的声明、点类的实现巴拉巴拉的圆类也一样

circle.h

#pragma once //防止头文件重复包含
#include<iostream>
using namespace std;
#include "point.h"

//一个类中用到了另一个类，circle类中用到了point类
//怎么办呢？
//只需包含point的这个类的头文件即可，让它知道有这么一个类的存在

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;
}

point.h

#pragma once //防止头文件重复包含
#include<iostream>

class Point
{
public:
	void setX(int x);
	int getX();

	void setY(int y);
	int getY();
	
private:
	int m_X;
	int m_Y;
};

point.cpp

#include "point.h"

//要加Point作用域， 因为这里需要的是成员函数
void Point::setX(int x)
{
	m_X = x;
}
int Point::getX()
{
	return m_X;
}

void Point::setY(int y)
{
	m_Y = y;
}
int Point::getY()
{
	return m_Y;
}

vs.cpp

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


//判断关系
void isInCircle(Circle& c, Point& p)
{
	//(x1 - x2)^2 + (y1 - y2)^2 计算两点之间距离 平方
	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);

	return 0;
}

注意：
1、作用域（如果需要的是成员函数，而这里是全局函数，就需要加上这个函数的作用域）；
2、一个类中用到了另一个类，只需包含这个类的头文件即可，让它知道有这么一个类的存在。

回顾案例核心两点：
1、在类中可以让另一个类作为本类的成员；
2、如何把一个类拆成不同的文件中。

文笙子

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
一、面向对象的三大特性之封装

面向对象的三大特性之封装C++认为万事万物皆为对象，对象上有其属性和行为。封装的意义：#将属性和行为作为一个整体，表现生活中的事物。#将属性和行为加以权限控制封装意义一在设计类的时候，属性和行为写在一起，表现事物。语法：class 类名 { 访问权限：属性 / 行为 }；示例一：设计一个圆类，求圆的周长。const double PI = 3.14;//class 代表设计一个类，类后面紧跟着的就是类名称class Circle{//访问权限，公共权限public:
复制链接

扫一扫