C++面向对象编程的三大特征为:封装、继承、多态
C++认为万事万物皆为对象,对象上有其属性和行为
1 封装
1.1 封装的意义
封装是C++面向对象三大特性之一
封装的意义:
(1)将属性和行为作为一个整体,表现生活中的事物
(2)将属性和行为加以权限控制
封装意义一:
在设计类的时候,属性和行为写在一起,表现事物
语法:class 类名 {访问权限:属性 / 行为}
#include <iostream>
using namespace std;
const double PI = 3.14;
//设计一个圆类,求圆的周长
class Circle
{
public://访问权限
//属性
int r;
//行为
double calculateZC()
{
return 2 * PI * r;
}
};
int main()
{
//通过圆;类,创建具体的圆
Circle c1;
//给圆对象的属性赋值
c1.r = 10;
//调用圆的方法
double result = c1.calculateZC();
cout << "周长为:" << result;
}
类中的属性和行为——统称为成员
(1)属性——成员属性、成员变量
(2)行为——成员函数、成员方法
#include <iostream>
#include <string>
using namespace std;
//设计一个中学生类,属性有姓名和学好,可以给姓名和学好赋值,可以显示学生的姓名和学好
class Student
{
public://访问权限
//属性
string name;
int id;
//行为
void show()
{
cout<<"姓名"<<name << "学号" << id <<endl;
}
void setName(string new_name)
{
name = new_name;
}
};
int main()
{
//通过学生类创建学生对象
Student s1;
//给学生对象的属性赋值
s1.name = "张三";
s1.id = 10086;
//调用学生的方法
s1.show();
s1.setName("赵四");
s1.show();
}
封装意义二:
类设计时,可以把属性和行为放在不同的权限下,加以控制
访问权限分为3种:
(1)public共有权限:成员——类内可以访问,类外可以访问
(2)protected保护权限:类内可以访问,类外不可访问 子类也可以访问父类的保护成员
(3)private私有权限:成员——类内可以访问,类外不可以访问 子类不可以访问父类的私有成员
#include <iostream>
#include <string>
using namespace std;
//访问权限
//公有权限public:成员——类内可以访问,类外可以访问
//保护权限protect:成员——类内可以访问,类外不可访问 子类也可以访问父类的保护成员
//私有权限private:成员——类内可以访问,类外不可以访问 子类不可以访问父类的私有成员
class Person
{
public:
//公共权限
string name;
protected:
//保护权限
string car;
private:
//私有权限
int password;
public:
//类内,三个种类型的成员都可访问
void func()
{
name = "张三";
car = "宝马";
password = 10086;
}
};
int main()
{
//实例化对象
Person p1;
//
p1.name = "李四";//公有权限,类外可以访问
//p1.car = "奔驰";//保护权限,类外不可访问
//p1.password=1002;//私有权限,类外不可以访问
}
1.2 struct和class的区别
在C++中struct和class唯一的区别就在于默认的访问权限不同
区别:
(1)struct默认权限为公有
(2)class默认权限为私有
#include <iostream>
#include <string>
using namespace std;
//struct默认权限是公有
//class默认权限是私有
class C1
{
int m_A;//默认权限为私有
};
struct C2
{
int m_A;//默认权限为公有
};
int main()
{
//类
C1 c1;
//c1.m_A = 100;//私有权限在类外不可以访问
//结构体
C2 c2;
c2.m_A = 100;//公有权限在类外可以访问
}
1.3 成员属性设置为私有
优点:
(1)将所有成员属性设置为私有,可以自己控制读写权限
(2)对于写权限,我们可以检测数据的有效性
#include <iostream>
#include <string>
using namespace std;
//成员属性设置为私有
//1.自己控制读写权限
//2.对于写权限可以检测数据的有效性
class Person
{
private:
string m_name;
int m_age;
string m_lover;
public:
//姓名:设置可读可写
void setName(string name)
{
m_name = name;
}
string getName()
{
return m_name;
}
//年龄:
int getAge()
{
m_age = 0;//初始化年龄为0岁
return m_age;
}
void setAge(int age)
{
if (age < 0 || age >150)
{
m_age = 0;//初始化年龄为0岁
cout << "你输入的年龄有误" << endl;
return;
}
m_age = age;
}
//情人:只写
void setLover(string lover)
{
m_lover = lover;
}
};
int main()
{
//类实例化对象:该对象不能访问、操作私有权限的成员,但是可以利用公有的方法
//操控私有权限的成员
Person p1;
//
p1.setName("张三");
cout << "姓名为:" << p1.getName() << endl;
p1.setAge(1000);
cout << "年龄为:" << p1.getAge() << endl;
p1.setLover("小三");
}
1.4 封装案例
案例1:设计立方体类,求出立方体的面积和体积,分别用全局函数和成员函数判断两个立方体是否相等
#include <iostream>
#include <string>
using namespace std;
//设计立方体类,求出立方体的面积和体积,
//分别用全局函数和成员函数判断两个立方体是否相等
class Cube
{
private:
int m_L;
int m_W;
int m_H;
public:
//设置高
void setH(int h)
{
m_H = h;
}
//获取高
int getH()
{
return m_H;
}
//设置宽
void setW(int w)
{
m_W = w;
}
//获取宽
int getW()
{
return m_W;
}
//设置长
void setL(int l)
{
m_L = l;
}
//获取高
int getL()
{
return m_L;
}
int square()//面积
{
return 2 * (m_L * m_W + m_H * m_W + m_L * m_H);
}
int volume()//体积
{
return m_H * m_L * m_W;
}
//利用成员函数判断两个立方体是否相等
bool judge(Cube& c)
{
if (c.getH() == m_H && c.getL() == m_L && c.getW() == m_W)
{
return true;
}
else
{
return false;
}
}
};
bool judge(Cube c1, Cube c2)//值传递,需要开辟内存空间,可以把参数改为 Cube &c1,Cube &c2这样不用开辟空间
{
if ((c1.getH() == c2.getH()) && (c2.getL() == c2.getL()) && (c2.getW() == c2.getW()))
{
return true;
}
else
{
return false;
}
}
int main()
{
//1.实例化立方体
Cube c1;
c1.setL(20);//设置长宽高
c1.setH(30);//设置长宽高
c1.setW(10);//设置长宽高
//2.立方体面积和体积
cout << "立方体面积:" << c1.square() << endl;
cout << "立方体体积:" << c1.volume() << endl;
//3.分别用全局函数和成员函数判断两个立方体是否相等
Cube c2;
c2.setL(20);//设置长宽高
c2.setH(30);//设置长宽高
c2.setW(10);//设置长宽高
//3.1 全局函数判断
cout << "判断结果为:" << judge(c1, c2) << endl;
//3.2 成员函数判断
cout << "判断结果为:" << c2.judge(c1) << endl;
}
案例2:点和圆的关系,设计一个圆类,和一个点类,计算点和圆的关系
注意:圆的圆心是点
#include <iostream>
#include <string>
using namespace std;
//点和圆的关系,设计一个圆类,和一个点类,计算点和圆的关系
class Point
{
private:
int x;
int y;
public:
//设置x,获取x
void setX(int new_x)
{
x = new_x;
}
int showX()
{
return x;
}
//设置y,获取y
void setY(int new_y)
{
y = new_y;
}
int showY()
{
return y;
}
};
class Circle
{
private:
Point center;//圆心:类型为Point类
int r;//半径
public:
//设置半径,获取半径
void setR(int new_R)
{
r = new_R;
}
int showR()
{
return r;
}
//设置圆心,获取圆心
void setCenter(Point point)
{
center = point;
}
Point showCenter()
{
return center;
}
};
//判断点和圆的关系
void judge(Point point, Circle circle)
{
Point center = circle.showCenter();
int x1 = center.showX();
int y1 = center.showY();
int x2 = point.showX();
int y2 = point.showY();
//1.计算两点之间的距离平方
int distence = (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
//2.计算半径的平方
int r_2 = circle.showR() * circle.showR();
//3.两者之间的关系
if (distence == r_2)
{
cout << "点在圆上" << endl;
}
else if(distence>r_2)
{
cout << "点在圆外" << endl;
}
else
{
cout << "点在圆内" << endl;
}
}
int main()
{
//1.圆
Circle c1;
c1.setR(5);
Point p1;
p1.setX(4);
p1.setY(6);
c1.setCenter(p1);
//2.点
Point p2;
p2.setX(4);
p2.setY(4);
//3.判断两者关系
judge(p2, c1);
}