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

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

例如：

人可以作为对象，属性有姓名、年龄、身高、体重...，行为有走、跑、跳、吃饭、唱歌...

车也可以作为对象，属性有轮胎、方向盘、车灯...，行为有载人、放音乐、开空调...

具有相同性质的对象，我们可以抽象为类，人属于人类，车属于车类。

封装

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

封装的意义：

1. 将属性和行为作为一个整体，表现生活中的事物

语法：class 类名 { 访问权限：属性 / 行为 };

#include<iostream>

using namespace std;

const double PI = 3.14;

//示例1：设计一个圆类，求圆的周长
//圆求周长的公式：2 * PI * 半径

//class代表要设计一个类
class Circle
{
	//访问权限
	//公共权限
public:
	//属性
	//半径
	int m_r;
	//行为
	//获取圆的周长
	double calculateZC()
	{
		return 2 * PI * m_r;
	}
};

int main1()
{
	//通过圆类创建具体的圆
	//实例化（通过一个类创建一个对象的过程）
	Circle c1;
	//给圆对象的属性进行赋值
	c1.m_r = 10;
	cout << "圆的周长为：" << c1.calculateZC() << endl;

	system("pause");
	return 0;
}

#include<iostream>

using namespace std;

//示例2：设计一个学生类，属性有姓名和学号
//可以给姓名和学号赋值，可以显示学生的姓名和学号

//设计学生类
class Student
{
//公共权限
public:
	//类中的属性和行为统称为成员
	//属性也叫成员属性、成员变量
	//行为也叫成员函数、成员方法

	//属性
	string m_Name; //姓名
	int m_Id; //学号
	//行为
	//显示姓名和学号
	void showStudent()
	{
		cout << "姓名：" << m_Name << " 学号：" << m_Id << endl;
	}
	//给姓名赋值
	void setName(string name)
	{
		m_Name = name;
	}
	//给学号赋值
	void setId(int id)
	{
		m_Id = id;
	}
};

int main2()
{
	//创建一个具体学生
	Student s1;
	//给s1对象进行属性赋值操作
	//s1.m_Name = "张三";
	s1.setName("张三");
	//s1.m_Id = 1;
	s1.setId(1);
	//显示学生信息
	s1.showStudent();

	Student s2;
	s2.m_Name = "李四";
	s2.m_Id = 2;
	s2.showStudent();

	system("pause");
	return 0;
}

2. 将属性和行为加一些权限控制

访问权限有三种：

public 公共权限

protected 保护权限

private 私有权限

#include<iostream>

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 main3()
{
	//实例化具体对象
	Person p1;
	p1.m_Name = "李四";
	//p1.m_Car = "奔驰"; //保护权限内容，在类外访问不到
	//p1.m_Password = 123; //私*限内容，在类外访问不到

	p1.func();

	system("pause");
	return 0;
}

struct和class区别

在C++中struct和class唯一的区别就在于默认的访问权限不同

struct默认权限为公共 public

class默认权限为私有 private

#include<iostream>

using namespace std;

class C1
{
	int m_A; //默认权限是私有
};

struct C2
{
	int m_A; //默认权限是公有
};

int main4()
{
	//在C++中struct和class唯一的区别就在于默认的访问权限不同

	//struct默认权限为公共 public
	C2 c2;
	c2.m_A = 100;

	//class默认权限为私有 private
	C1 c1;
	//c1.m_A = 100;

	system("pause");
	return 0;
}

成员属性设置为私有

优点1：将所有成员属性设置为私有，可以自己控制读写权限

优点2：对于写权限，我们可以检测数据的有效性

#include<iostream>

using namespace std;

#include<string>

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

//设计人类
class Person1
{
public:
	//写姓名
	void setName(string name)
	{
		m_Name = name;
	}
	//读姓名
	string getName()
	{
		return m_Name;
	}
	//写年龄
	void setAge(int age)
	{
		if (age < 0 || age > 150)
		{
			m_Age = 0;
			cout << "输入范围有误" << endl;
			return;
		}
		m_Age = age;
	}
	//读年龄
	int getAge()
	{
		//m_Age = 0; //初始化为0岁
		return m_Age;
	}
	//写情人
	void setLover(string lover)
	{
		m_Lover = lover;
	}

private:
	//姓名 可读可写
	string m_Name;
	//年龄 可读可写 如果想修改，年龄的范围必须是0~150之间
	int m_Age;
	//情人 只写
	string m_Lover;
};

int main5()
{
	Person1 p;
	p.setName("张三");
	cout << "姓名：" << p.getName() << endl;

	//p.m_Age = 18;
	p.setAge(18);
	cout << "年龄：" << p.getAge() << endl;

	p.setLover("大桥");

	system("pause");
	return 0;
}

案例1：设计立方体类

求出立方体的面积和体积

分别用全局函数和成员函数判断两个立方体是否相等

#include<iostream>

using namespace std;

//设计立方体类
//求出立方体的面积和体积
//分别用全局函数和成员函数判断两个立方体是否相等

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_L * m_H + 2 * m_W * 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;
	}
	return false;
}

int main6()
{
	//创建立方体对象
	Cube c1;
	c1.setL(10);
	c1.setW(10);
	c1.setH(10);
	cout << "c1的面积为：" << c1.calculateS() << endl;
	cout << "c1的体积为：" << c1.calculateV() << endl;

	Cube c2;
	c2.setL(10);
	c2.setW(10);
	c2.setH(10);
	cout << "c2的面积为：" << c2.calculateS() << endl;
	cout << "c2的体积为：" << c2.calculateV() << endl;

	//全局函数判断
	bool ret = isSame(c1, c2);
	if (ret)
	{
		cout << "全局函数判断：c1和c2是相等的" << endl;
	}
	else
	{
		cout << "全局函数判断：c1和c2是不相等的" << endl;
	}

	//成员函数判断
	bool ret2 = c1.isSameByClass(c2);
	if (ret2)
	{
		cout << "成员函数判断：c1和c2是相等的" << endl;
	}
	else
	{
		cout << "成员函数判断：c1和c2是不相等的" << endl;
	}

	system("pause");
	return 0;
}

案例2：圆和点的关系

设计一个圆形类，和一个点类，计算圆和点的关系

#include<iostream>

using namespace std;

#include "circle.h"

#include "point.h"

//设计一个圆形类，和一个点类，计算圆和点的关系

点类
//class Point2
//{
//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; //x坐标
//	int m_Y; //y坐标
//};

圆类
//class Circle2
//{
//public:
//	//设置半径
//	void setR(int r)
//	{
//		m_R = r;
//	}
//
//	//获取半径
//	int getR()
//	{
//		return m_R;
//	}
//
//	//设置圆心
//	void setCenter(Point2 center)
//	{
//		m_Center = center;
//	}
//
//	//获取圆心
//	Point2 getCenter()
//	{
//		return m_Center;
//	}
//
//private:
//	int m_R; //半径
//
//	//在类中可以让另一个类作为本类中的成员
//	Point2 m_Center; //圆心
//};

//判断点和圆的关系
void isInCircle(Circle2 &c, Point2 &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 main7()
{
	//创建一个圆
	Circle2 c;
	c.setR(10);
	Point2 center;
	center.setX(10);
	center.setY(0);
	c.setCenter(center);

	//创建一个点
	Point2 p;
	p.setX(10);
	p.setY(11); //点在圆外
	isInCircle(c, p);

	p.setY(10); //点在圆上
	isInCircle(c, p);

	p.setY(9); //点在圆内
	isInCircle(c, p);

	system("pause");
	return 0;
}

#pragma once

#include<iostream>

using namespace std;

#include "point.h"

//圆类
class Circle2
{
public:
	//设置半径
	void setR(int r);

	//获取半径
	int getR();

	//设置圆心
	void setCenter(Point2 center);

	//获取圆心
	Point2 getCenter();

private:
	int m_R; //半径

	//在类中可以让另一个类作为本类中的成员
	Point2 m_Center; //圆心
};

#include "circle.h"

//圆类
//设置半径
void Circle2::setR(int r)
{
	m_R = r;
}

//获取半径
int Circle2::getR()
{
	return m_R;
}

//设置圆心
void Circle2::setCenter(Point2 center)
{
	m_Center = center;
}

//获取圆心
Point2 Circle2::getCenter()
{
	return m_Center;
}

#pragma once

#include<iostream>

using namespace std;

//点类
class Point2
{
public:
	//设置x
	void setX(int x);

	//获取x
	int getX();

	//设置y
	void setY(int y);

	//获取y
	int getY();

private:
	int m_X; //x坐标
	int m_Y; //y坐标
};

#include "point.h"

//点类
//设置x
void Point2::setX(int x)
{
	m_X = x;
}

//获取x
int Point2::getX()
{
	return m_X;
}

//设置y
void Point2::setY(int y)
{
	m_Y = y;
}

//获取y
int Point2::getY()
{
	return m_Y;
}