C++系列内容的学习目录 → \rightarrow → C++学习系列内容汇总。
C++在C语言的基础上增加了面向对象编程，C++支持面向对象的程序设计。类是C++的核心特性，通常被称为用户定义的类型。类用于指定对象的形式，它包含了数据表示法和用于处理数据的方法。类中的数据和方法称为类的成员。
类的基本思想是数据抽象(data abstraction)和封装(encapsulation)。
数据抽象是一种依赖于接口(interface)和实现(implementation)分离的编程（以及设计）技术。类的接口包括用户所能执行的操作；类的实现则包括类的数据成员、负责接口实现的函数体以及定义类所需的各种私有函数。
封装实现了类的接口和实现的分离。封装后的类隐藏了它的实现细节，也就是说，类的用户只能使用接口而无法访问实现部分。
C++面向对象的三大特性为：封装、继承、多态。
C++认为万事万物都皆为对象，对象上有其属性和行为。
例如： 人可以作为对象，属性有姓名、年龄、身高、体重…，行为有走、跑、跳、吃饭、唱歌…
车也可以作为对象，属性有轮胎、方向盘、车灯…，行为有载人、放音乐、放空调…
具有相同性质的对象，我们可以抽象称为类，人属于人类，车属于车类
1. 封装1.1 封装的意义
封装是C++面向对象的三大特性之一，是面向对象编程中的把数据和操作数据的函数绑定在一起的一个概念，这样能避免受到外界的干扰和误用，从而确保了安全。
封装的优点：1. 确保用户代码不会无意间破坏封装对象的状态；
2. 被封装的类的具体实现细节可以随时改变，而无须调整用户级别的代码。
封装的意义：1. 将属性和行为作为一个整体，表现生活中的事物；
2. 将属性和行为加以权限控制。
封装意义1： 在设计类的时候，将属性和行为写在一起，表现事物。
语法： class 类名{ 访问权限： 属性 / 行为 };
例1： 设计一个圆类，求圆的周长。
using namespace std;
const double PI = 3.14; //圆周率
//设计一个圆类，求圆的周长（周长公式：2 * PI * 半径）
class Circle //class代表设计一个类
{
//访问权限
public: //公共权限
//属性（变量）
int m_r; //半径
//行为（函数）
double calculateZC() //获取圆的周长
{
return 2 * PI * m_r;
}
};
int main()
{
//通过圆类创建一个具体的圆（对象）
//实例化：通过一个类，创建一个对象的过程
Circle cl; //cl是具体的圆
//给圆对象的属性进行赋值
cl.m_r = 10;
cout << "圆的周长为：" << cl.calculateZC() << endl;
system("pause");
return 0;
}
圆的周长为：62.8
例2： 设计一个学生类，属性有姓名和学号，给姓名和学号赋值，可以显示学生的姓名和学号。
using namespace std;
//设计一个学生类，属性有姓名和学号，给姓名和学号赋值，可以显示学生的姓名和学号。
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 main()
{
//通过学生类创建一个具体的学生（对象）
Student s1; //实例化对象
//给s对象的属性进行赋值
//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;
}
学生的姓名：张三 学生的学号：1
学生的姓名：李四 学生的学号：2
封装意义2： 类在设计时，可以把属性和行为放在不同的权限下，加以控制。
访问权限有三种：
- public 公有权限
- protected 保护权限
- private 私有权限
实例如下所示。
using namespace std;
//访问权限有三种：
//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 = "张三";
m_Car = "拖拉机";
m_Password = 123456;
}
};
int main()
{
//实例化对象
Person p1;
p1.m_Name = "李四";
//p1.m_Car = "奔驰"; //保护权限内容，在类外访问不到
//p1.m_Password = 123789; //私有权限内容，在类外访问不到
p1.func();
system("pause");
return 0;
}
1.2 struct和class区别
在C++中struct和class唯一的区别就在于默认的访问权限不同：
- struct 默认权限为公有public；
- class 默认权限为私有private。
实例如下所示。
using namespace std;
class C1
{
int m_A; //class的默认权限是私有private
};
struct C2
{
int m_A; //struct的默认权限是公有public
};
int main()
{
//struct和class的区别：
//struct的默认权限是公有public； class的默认权限是私有private
C1 c1;
//c1.m_A = 100; //错误，在class中默认权限是私有，因此类外不可以访问
C2 c2;
c2.m_A = 100; //正确，在struct中默认权限是公有，因此类外可以访问
system("pause");
return 0;
}
1.3 成员属性设置为私有
将成员属性设置为私有的优点：
- 将所有成员属性设置为私有，可以自己控制读写权限；
- 对于写权限，我们可以检测数据的有效性。
优点1的实例如下所示。
using namespace std;
//将成员属性设置为私有
//1. 将所有成员属性设置为私有，可以自己控制读写权限
//2. 对于写权限，我们可以检测数据的有效性
class Person
{
public:
//设置姓名
void setName(string name)
{
m_Name = name;
}
//获取姓名
string getName()
{
return m_Name;
}
//获取年龄
int getAge()
{
m_Age = 20;
return m_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.m_Age = 18; //错误，年龄只读
//p.setAge(18);
cout << "年龄为：" << p.getAge() << endl;
p.setLover("小红");
//cout << "爱人为：" << p.getLover() << endl; //错误，爱人在类外不可访问，只写
system("pause");
return 0;
}
姓名为：张三
年龄为：20
优点2 的实例如下所示。
using namespace std;
//将成员属性设置为私有
//1. 将所有成员属性设置为私有，可以自己控制读写权限
//2. 对于写权限，我们可以检测数据的有效性
class Person
{
public:
//设置姓名
void setName(string name)
{
m_Name = name;
}
//获取姓名
string getName()
{
return m_Name;
}
//设置年龄
void setAge(int age)
{
if (age < 0 || age > 150) //（年龄必须在0~150之间）
{
m_Age = 0;
cout << "输入有误！" << endl;
return;
}
m_Age = age;
}
//获取年龄
int getAge()
{
return m_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.getLover() << endl; //错误，爱人在类外不可访问，只写
system("pause");
return 0;
}
姓名为：张三
年龄为：18
练习案例1： 设计立方体类(Cube)。（1）求出立方体的面积和体积；（2）分别用全局函数和成员函数判断两个立方体是否相等。
练习案例1的代码如下所示。
using namespace std;
//设计立方体类
//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 calculateS()
{
return 2 * m_L*m_W + 2 * m_W*m_H + 2 * m_H*m_L;
}
//获取立方体体积
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;
}
else
{
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;
}
else
{
return false;
}
}
int main()
{
Cube c1; //创建第一个立方体对象c1
c1.setL(10);
c1.setW(10);
c1.setH(10);
cout << "立方体c1的面积为：" << c1.calculateS() << endl;
cout << "立方体c1的体积为：" << c1.calculateV() << endl;
Cube c2; //创建第二个立方体对象c2
c2.setL(10);
c2.setW(10);
c2.setH(11);
//利用全局函数判断两个立方体是否相等
bool ret = isSame(c1, c2);
if (ret)
{
cout << "全局函数判断：c1和c2相等！" << endl;
}
else
{
cout << "全局函数判断：c1和c2不相等！" << endl;
}
//利用成员函数判断两个立方体是否相等
ret = c1.isSameByClass(c2);
if (ret)
{
cout << "成员函数判断：c1和c2相等！" << endl;
}
else
{
cout << "成员函数判断：c1和c2不相等！" << endl;
}
system("pause");
return 0;
}
立方体c1的面积为：600
立方体c1的体积为：1000
全局函数判断：c1和c2不相等！
成员函数判断：c1和c2不相等！
练习案例2： 点和圆的关系。设计一个圆形类（Circle），和一个点类（Point），计算点和圆的关系。
练习案例2的代码编写思路如下所示。
练习案例2的代码如下所示。
- 整体编写代码
using namespace std;
//点和圆的关系
//点类
class Point
{
public:
void setX(int x) //设置X
{
m_X = x;
}
int getX() //获取X
{
return m_X;
}
void setY(int y) //设置Y
{
m_Y = y;
}
int getY() //获取Y
{
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 center;
center.setX(10);
center.setY(0);
c.setCenter(center);
Point p; //创建点
p.setX(10);
p.setY(10);
//判断关系
isInCircle(c, p);
system("pause");
return 0;
}
点在圆上
- 分文件编写代码
point.h
using namespace std;
//点类
class Point
{
public:
void setX(int x); //设置X
int getX(); //获取X
void setY(int y); //设置Y
int getY(); //获取Y
private:
int m_X;
int m_Y;
};
point.cpp
void Point::setX(int x) //设置x
{
m_X = x;
}
int Point::getX() //获取x
{
return m_X;
}
void Point::setY(int y) //设置y
{
m_Y = y;
}
int Point::getY() //获取y
{
return m_Y;
}
circle.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
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;
}
点和圆的关系.cpp
using namespace std;
//圆类
//点类
//判断点和圆的关系
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 center;
center.setX(10);
center.setY(0);
c.setCenter(center);
Point p; //创建点
p.setX(10);
p.setY(10);
//判断关系
isInCircle(c, p);
system("pause");
return 0;
}
点在圆上
1.4 总结
