C++进阶4（类和对象——封装）

最新推荐文章于 2024-09-08 22:35:29 发布

南往无念

最新推荐文章于 2024-09-08 22:35:29 发布

阅读量57

点赞数

本文链接：https://blog.csdn.net/wyx66666/article/details/117334975

版权

C++进阶专栏收录该内容

15 篇文章 1 订阅

订阅专栏

本文介绍了C++中的面向对象特性——封装，包括其意义和实际应用。通过实例展示了如何使用类和对象封装属性和行为，以及访问权限的控制，如public、protected和private。同时，讲解了成员变量设为私有的优点，确保数据安全性和有效性。最后，通过立方体和点类的案例说明了封装在实际编程中的运用。

摘要由CSDN通过智能技术生成

封装意义1

//类和对象
//C++面向对象的三大特性为：封装，继承，多态
//C++认为万事万物皆为对象，对象上有其属性和行为
//例如：
// 人可以作为对象，属性有姓名、年龄、身高、体重…，行为有走、跑、跳、吃饭、唱歌…
// 车也可以作为对象，属性有轮胎、方向盘、车灯…, 行为有载人、放音乐、放空调…
// 具有相同性质的对象，我们可以抽象称为类，人属于人类，车属于车类

/*封装是C++面向对象三大特性之一
封装的意义：
将属性和行为作为一个整体，表现生活中的事物
将属性和行为加以权限控制*/

/*封装的意义一：在设计类的时候，属性和行为写在一起，表现事物
语法：class 类名{ 访问权限:  属性 / 行为 };

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

#include <iostream>
using namespace std;
const double PI = 3.14;
//class 代表设计一个类，类后边紧跟着的事类名称
//示例一
class Circle
{
	//访问权限：公共权限
public:
	//属性:半径
	int r;
	//行为：获取圆的周长
	double calculateZC()
	{
		return 2 * PI * r;
	}
};
//示例二：*设计一个学生类，属性有姓名和学号，可以给姓名和学号赋值，可以显示学生的姓名和学号
class student
{
public:  //公共权限
	//类中的属性和行为我们统一称为成员    
	//属性也称为成员属性，成员变量
	//行为也称为成员函数  成员变量
	//属性
	string name;
	int id;
	//行为
	void showstudent()
	{
		cout << "姓名：" << name << "  学号：" << id << endl;
	}
	//给姓名赋值(利用行为对属性进行赋值)
	void setName(string name1)
	{
		name = name1;
	}
	void setId(int  id1)
	{
		id = id1;
	}
};
//封装的意义二
//类在设计时，可以把属性和行为放在不同的权限下，加以控制
//访问权限有三种：
//public 公共权限		成员 类内可以访问   类外也可以访问
//protected 保护权限	成员 类内可以访问   类外不可以访问  儿子也可以访问父亲的保护内容
//private 私有权限		成员 类内可以访问   类外不可以访问  儿子不可以访问父亲的私有内容
class person
{
	//公共权限
public:
	string name;
	//保护权限
protected:
	string car;
	//私有权限
private:
	int password;
public:
	void func1()
	{
		name = "张三";
		car = "拖拉机";
		password = 123456;
	}
};
//C++中 struct 和 class 默认的访问权限不同
//	  struct 默认权限为公共
//	  class 默认权限为私有
struct C2
{
	int A;//默认权限是 公共
};
class C1
{
	int A;//默认权限是 私有   
};
int main()
{
	cout << "封装的意义部分:" << endl;
	//通过圆类 创建具体的圆（对象）    实例化 
	Circle c;
	c.r = 10;
	cout << "圆的周长为：" << c.calculateZC() << endl;
	cout << "\n " << endl;
	//创建一个具体学生， 实例化对象
	student s1;
	//给s1对象   进行属性赋值操作
	//s1.name = "张三";
	s1.setName("张三");
	//s1.id = 1;
	s1.setId(1);
	s1.showstudent();
	student s2;
	s2.name = "李四";
	s2.id = 2;
	s2.showstudent();
	cout << "\n " << endl;
	//实例化人类具体对象
	person p1;
	p1.name = "李四";
	//p1.car = "奔驰";			报错  保护权限的内容在类外访问不到
	//p1.password = "1234567";	报错  私有权限的内容在类外访问不到
	p1.func1();//可以利用成员方法访问类内私有权限的成员变量
	cout << "\n " << endl;
	cout << "struct 和 class的区别部分：" << endl;
	C1 c1;
	C2 c2;
	//c1.A = 100;报错，class中默认权限是私有，因此在类外是不能访问的
	c2.A = 100;//在struct中默认的权限为公共，因此可以访问
	cout << "\n " << endl;
	system("pause");
	return 0;
}

成员属性设置为私有及其优点

#include <iostream>

using namespace std;
/*成员变量属性设置为私有
优点1：** 将所有成员属性设置为私有，可以自己控制读写权限
优点2：** 对于写权限，我们可以检测数据的有效性*/
class Person
{
public:
	//设置姓名通过public提供公共的接口
	void setName(string name)
	{
		m_Name = name;
	}
	//获取姓名
	string getName()
	{
		return m_Name;
	}
	//获取年龄
	int getAge()
	{
		//m_Age = 10;//年龄初始化为10岁
		return m_Age;
	}
	//设置年龄(判断数据有效性案例)
	void setAge(int Age)
	{
		if (Age < 0 || Age>150)
		{
			Age = 0;
			cout << "输入年龄有误！返回默认值" << endl;
			m_Age = Age;
			return;
		}
		m_Age = Age;
		cout << m_Age << endl;
	}
	//设置情人
	void setLover(string lover )
	{
		m_Lover=lover;
	}

private://类外无权限访问
	//姓名  可读可写
	string m_Name;
	//年龄  只读（修改为：如果想修改范围必须是0-100之间，否则默认为0）
	int m_Age;
	//情人  只写
	string m_Lover;
};
int main()
{
	Person p;
	p.setName("张三");
	cout << "姓名为：" << p.getName() << endl;
	//cout << "年龄为：" << p.getAge() << endl;
	p.m_Age = 18;报错
	实现了只读不可写
	p.setLover("cang老师");//设置情人
	//cout << "情人为：" << p.Lover() << endl;报错
	//实现只写不可读
	p.setAge(-1);
	cout << "年龄为：" << p.getAge() << endl;
	p.setAge(1000);
	cout << "年龄为：" << p.getAge() << endl;
	p.setAge(18);
	cout << "年龄为：" << p.getAge() << endl;
	cout << "\n " << endl;
	system("pause");
	return 0;
}

封装案例一

#include<iostream>
using namespace std;
//练习案例1：设计立方体类
//设计立方体类(Cube)
//求出立方体的面积和体积
//分别用全局函数和成员函数判断两个立方体是否相等。
//案例一
class Cube
{
	//行为
	// 设置获取长宽高
public:
	void setL(double l)
	{
		m_L = l;
	}
	double getL()
	{
		return m_L;
	}
	void setW(double w)
	{
		m_W = w;
	}
	double getW()
	{
		return m_W;
	}
	void setH(double h)
	{
		m_H = h;
	}
	double getH()
	{
		return m_H;
	}
	//获取立方体面积
	double S()
	{
		return 2 * (m_L * m_W + m_L * m_H + m_H * m_W);
	}
	//获取立方体体积
	double V()
	{
		return m_H * m_L * m_W;
	}
	//利用成员函数来判断两个立方体是否相等
	bool isSameClass(Cube& c)
	{
		if (m_H == c.getH() && m_L == c.getL() && m_W == c.getW())
		{
			return true;
		}
		return false;
	}
	//属性
private://属性私有
	double m_L;
	double m_W;
	double m_H;

};
//利用全局函数来判断两个立方体是否相等
bool isSame(Cube& c1, Cube& c2)
{
	if (c1.getH() == c2.getH() && c1.getL() == c2.getL() && c1.getW() == c2.getW())
	{
		return true;
	}
	return false;
}
int main()
{
	//案例一
	//创建立方体对象
	cout << "案例一 " << endl;
	Cube c1;
	c1.setL(10);
	c1.setH(10);
	c1.setW(10);
	cout << "c1的面积为：" << c1.S() << endl;
	cout << "c1的体积为：" << c1.V() << endl;
	Cube c2;

	c2.setL(10);
	c2.setH(10);
	c2.setW(10);
	cout << "c2的面积为：" << c2.S() << endl;
	cout << "c2的体积为：" << c2.V() << endl;
	bool ret = isSame(c1, c2);
	if (ret)
	{
		cout << "（全局函数）c1和c2相等的" << endl;
	}
	else
	{
		cout << "（全局函数）c1和c2不相等的" << endl;
	}
	ret = c1.isSameClass(c2);//利用成员函数判断
	if (ret)
	{
		cout << "（成员函数）c1和c2相等的" << endl;
	}
	else
	{
		cout << "（成员函数）c1和c2不相等的" << endl;
	}
	cout << "\n " << endl;
	system("pause");
	return 0;
}

此处封装案例二，文件分写怎么写

main函数部分

#include <iostream>
#include"封装案例circle.h"
#include"封装案例point.h"
using namespace std;
//案例二
//设计一个圆形类（Circle），和一个点类（Point），计算点和圆的关系。
//圆类
//点类
//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)
{
	//计算两点间平方
	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();
	cout << distance << endl;
	cout << rDistance << endl;
	//判断关系
	if (distance == rDistance)
	{
		cout << "点在圆上" << endl;
	}
	else if (distance > rDistance)
	{
		cout << "点在圆外" << endl;
	}
	else
	{
		cout << "点在圆内" << endl;
	}
}
int main()
{
	cout << "案例二" << endl;
	Circle c4;
	c4.setR(10);
	Point center;
	center.setX(10);
	center.setY(0);
	c4.setCenter(center);
	Point p1;
	p1.setX(10);
	p1.setY(10);
	isInCircle(c4, p1);
	/*p1.setY(11);*/
	Point p2;
	p2.setX(0);
	p2.setY(10);
	isInCircle(c4, p2);
	Point p3;
	p3.setX(1);
	p3.setY(0);
	isInCircle(c4, p3);
	cout << "\n " << endl;
	system("pause");
	return 0;
}

circle头文件部分

#pragma once//防止头文件重复包含
#include "封装案例point.h"
#include<iostream>
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;
};

point头文件部分

#pragma once
#include <iostream>
using namespace std;
class Point
{
public:
	void setX(int x);

		int getX();

	void setY(int y);

		int getY();
private:
	int m_x;
	int m_y;

};

circle.cpp分文件部分

#include"封装案例circle.h"

void Circle::setR(int r)//函数不是全局变量，是在Circle作用域下的成员变量
{
	m_R = r;
}
int Circle::getR()
{
	return m_R;
}
void Circle::setCenter(Point center)
{
	m_center = center;
}
Point Circle::getCenter()
{
	return m_center;
}

point.cpp分文件部分


#include "封装案例point.h"

	
void Point::setX(int x)//不加Point:: 会报错，因为那是全局函数
						//加上Point之后表示在Point作用域下的成员函数
{
	m_x = x;
}
int Point::getX()
{
	return m_x;
}
void Point::setY(int y)
{
	m_y = y;
}
int Point::getY()
{
	return m_y;
}