练习 ~黑马程序员匠心之作-第三阶段C++核心编程-P99~P105-类和对象-封装

最新推荐文章于 2022-11-01 16:11:23 发布

lilyfengli

最新推荐文章于 2022-11-01 16:11:23 发布

阅读量744

点赞数 2

分类专栏：黑马程序员匠心之作C++教程从0到1入门编程文章标签： c++

本文链接：https://blog.csdn.net/qq_43964914/article/details/107351159

版权

黑马程序员匠心之作C++教程从0到1入门编程专栏收录该内容

26 篇文章 24 订阅

订阅专栏

黑马程序员匠心之作|C++教程从0到1入门编程

关于P99~P105-练习-类和对象-封装

1、属性和行为作为主体
2、案例-设计学生类
3、访问权限
4、C++中struct和class的区别
5、成员属性私有化
6、设计案例1-设计立方体类
7、设计案例2-点和圆关系
8、类的分文件编写

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

封装：
封装的意义：
封装是C++面向对象三大特性之一
意义：

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

1、属性和行为作为主体

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

#include<iostream>
using namespace std;

//圆周率
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;

	//2*PI*10=62.8
	cout << "圆的周长为：" << c1.calculateZC() << endl;


	system("pause");
	return 0;
}

在这里插入图片描述

2、案例-设计学生类

示例2：设计一个学生类，属性有姓名和学号，可以给姓名和学号赋值，可以显示学生的姓名和学号。（可以直接给属性赋值，也可以通过行为给属性赋值）

#include<iostream>
#include<string>
using namespace std;
//设计一个学生类
//属性  姓名和学号
//行为  可以给姓名和学号赋值，可以显示学生的姓名和学号。
class Student
{
public: //公共权限
	//类中属性和行为 我们统一称为 成员
	//属性  成员属性 成员变量
	//行为  成员方法 成员函数

	 //属性
	string m_name;//姓名
	int m_id;//学号

	void setName(string name)
	{
		m_name = name;
	}
	void setId(int id)
	{
		m_id = id;
	}
	void showStudent()
	{
		cout << "姓名：" << m_name << " 学号：" << m_id << endl;
	}
};

int main()
{
	//具体学生 实例化
	Student s1;
	//s1.m_name = "张三";
	s1.setName ( "张三");
	//s1.id = 111;
	s1.setId(111);
	s1.showStudent();

	Student s2;
	s2.setId(222);
	s2.setName("李四");
	s2.showStudent();


	system("pause");
	return 0;
}

在这里插入图片描述
注意：
1、类中属性和行为我们统一称为成员
2、属性成员属性成员变量
3、行为成员方法成员函数

3、访问权限

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

#include<iostream>
#include<string>
using namespace std;
//三种权限
//1、public     公共权限  类内可以访问  类外可以访问
//2、protected  保护权限  类内可以访问  类外不可以访问 儿子可以访问父亲中的保护内容
//3、private    私有权限  类内可以访问  类外不可以访问 儿子不可以访问父亲的私有内容

class Person
{
	//1、公共权限
public:
	string m_Name;//姓名

	//2、保护权限 
protected:
	string m_Car;//汽车

	//3、私有权限
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;//报错，私有权限，类外不可访问
	
	system("pause");
	return 0;
}

4、C++中struct和class的区别

在C++中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  默认权限是 私有 类外不可访问
	struct C2 c2;
	c2.m_A = 100;//正确，struct 默认权限是 公有 类外可访问

	system("pause");
	return 0;
}

5、成员属性私有化

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

#include<iostream>
#include<string>
using namespace std;

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

//设计人类
class Person
{
public:
	//设置姓名
	void setName(string name)
	{
		m_Name = name;
	}
	//获取姓名
	string getName()
	{
		return m_Name;
	}
	//获取年龄  可读可写 如果想修改（年龄的范围必须是0~150之间）
	int getAge()
	{
		//m_Age = 0;//初始化为0岁
		return m_Age;
	}
	//设置年龄
	void setAge(int age)
	{
		if (age < 0 || age>150)
		{
			m_Age = 0;
			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("张三");//写
	//p.m_Age = 18;//只读，不可写
	p.setAge(10000);
	//p.setAge(10);
	cout << "姓名为：" << p.getName() << endl;//读
	cout << "年龄为：" << p.getAge() << endl;//读
	p.setLover("李四");//写
	//cout << "年龄为：" << p.m_Lover() << endl;//只写，不可读

	system("pause");
	return 0;
}

在这里插入图片描述

6、设计案例1-设计立方体类

设计立方体类（Cube）
求出立方体的面积和体积
分别用全局函数和成员函数判断两个立方体是否相等
在这里插入图片描述

#include<iostream>
#include<string>
using namespace std;

//设计立方体类（Cube）
//1、创建立方体类
//2、设计属性
//3、设计行为 求出立方体的面积和体积
//4、分别用全局函数和成员函数判断两个立方体是否相等
class Cube
{
private:
	int m_L;//长
	int m_W;//宽
	int m_H;//高
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 + m_L * m_H + m_W * m_H);
	}
	//获取立方体体积
	int calculateV()
	{
		return m_L * m_W * m_H;
	}

	//用成员函数判断两个立方体是否相等
    bool isSameByCube(Cube &c)
	{
		return (m_H == c.getH()) && (m_L == c.getL()) && (m_W == c.getW());
	}
};

//用全局函数判断两个立方体是否相等
bool isSame(Cube &c1, Cube &c2)//用引用传递，不用拷贝一份数据了
{
	return (c1.getH() == c2.getH()) && (c1.getL() == c2.getL()) && (c1.getW() == c2.getW());
}
	
int main()
{   
	//创建立方体对象
	Cube c1;
	c1.setL(10);
	c1.setW(10);
	c1.setH(10);
	cout << "c1的面积为：" << c1.calculateS() << endl;//600
	cout << "c1的体积为：" << c1.calculateV() << endl;//1000

	//创建第2个立方体对象
	Cube c2;
	c2.setL(10);
	c2.setW(10);
	c2.setH(10);

	if (isSame(c1,c2))
	{
		cout <<"isSame(c1,c2)-两个立方体相等" << endl;
	}
	else
	{
		cout << "isSame(c1,c2)-两个立方体不相等" << endl;
	}

	if (c1.isSameByCube(c2))
	{
		cout << "isSameByCube-两个立方体相等" << endl;
	}
	else
	{
		cout << "isSameByCube-两个立方体不相等" << endl;
	}

	system("pause");
	return 0;
}

7、设计案例2-点和圆关系

设计一个圆形类（Circle），和一个点类（Point），计算点和圆的关系。
在这里插入图片描述
分析：

#include<iostream>
#include<string>
using namespace std;

//设计一个圆形类（Circle）
//一个点类（Point）
//计算点和圆的关系。

//点类
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 p1;
	p1.setX(10);
	p1.setY(0);
	c.setCenter(p1);
	//创建点
	Point p2;
	p2.setX(10);
	p2.setY(10);
	//判断关系,上
	isInCircle(c, p2);

	//创建点
	Point p3;
	p3.setX(10);
	p3.setY(9);
	//判断关系，内
	isInCircle(c, p3);

	//创建点
	Point p4;
	p4.setX(10);
	p4.setY(14);
	//判断关系，外
	isInCircle(c, p4);

	system("pause");
	return 0;
}

在这里插入图片描述
注意：
1、在Circle类中可以让Point类作为本类中的成员
2、类太多怎么办？

8、类的分文件编写

8.1Point类

point.h

1、在开头加上以下代码

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

2、将Point类复制粘贴到这里，进行修改。将成员函数的函数体删除，只留下函数名，并在后面加上分号（声明函数）。

3、最终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

1、在开头加上：#include"point.h"
2、将Point类复制粘贴到这里，进行修改。只留下成员函数，剩下的都删除，并在成员函数名前加上Point::。
3、最终point.cpp为：

#include"point.h"

//设置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;
}

8.2Circle类

circle.h

1、在开头加上以下代码，比point.h多了#include"point.h"

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

2、将Circle类复制粘贴到这里，进行修改。将成员函数的函数体删除，只留下函数名，并在后面加上分号（声明函数）。

3、最终 circle.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

1、在开头加上：#include"circle.h""
2、将Circle类复制粘贴到这里，进行修改。只留下成员函数，剩下的都删除，并在成员函数名前加上Circle::。
3、最终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;
}

8.3源.cpp

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

//判断点和圆的关系
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 p1;
	p1.setX(10);
	p1.setY(0);
	c.setCenter(p1);
	//创建点
	Point p2;
	p2.setX(10);
	p2.setY(10);
	//判断关系,上
	isInCircle(c, p2);

	//创建点
	Point p3;
	p3.setX(10);
	p3.setY(9);
	//判断关系，内
	isInCircle(c, p3);

	//创建点
	Point p4;
	p4.setX(10);
	p4.setY(14);
	//判断关系，外
	isInCircle(c, p4);

	system("pause");
	return 0;
}