C++ 类和对象
0.前言
C++面向对象的三大特性为：封装，继承，多态
一般来讲高级语言如 C++ Java 都认为万事万物皆为对象，对象上有其属性和行为。
对象：
你所见到的东西都可以称之为对象。
比如一个叫张三的人：可以作为一个对象：属性有姓名、年龄、身高、体重、、、行为有走、跑、跳、唱歌、、、
在比如一辆奔驰车：也可以作为一个对象：属性有轮胎、方向盘、车灯、、、行为有载人、放音乐、放空调、跑路、、、
类：
具有相同性质的对象，我们可以抽象称为类。人属于人类，车属于车类。
（物以类聚，人以群分）
1.封装
封装是C++面向对象的三大特征之一
1.1 封装的意义：
1.1.1将属性和行为作为一个整体，表现生活中的事物。
一般来讲将属性和行为绑在一起才算是一个整体，
有点哲学的感觉，属性和行为更像是存在和存在的意义。
语法：class 类名 { 访问权限：属性 / 行为 }
示例1：设计一个园类，求圆的周长
#include<iostream>
using namespace std;
设计一个圆类，求圆的周长
圆求周长？？ 公式：2*pi*r
那么半径可当作一个属性，
（当然了直径，圆心，弧长，角度等等都可以是属性，但是这里没有必要写入啊！）
const double pi = 3.1415;
//class 代表设计一个类，类后面紧跟的就是类的名称
class Cricle
{
public : //访问权限(公共权限)
int Cri_r; //属性(半径)
double Cri_calculate()//行为（获取圆的周长）
{
return 2 * pi*Cri_r;
}
};
/我们现在有一个类了，但是还没有具体的圆。
就是有了圆这个名词了，但是还没有具像，
就像有了人这个名词，但是还没有具体到某个人
int main()
{
有了类还不是具体的内容，要通过类来创建具体的对象。来实例化出来一个圆。
实例化（通过一个类来创建一个对象的过程）
Cricle C1;
C1.Cri_r = 3;
cout << "圆的周长为：" << C1.Cri_calculate() << endl;
system("pause");
return 0;
}
示例2：学生信息类
#include<iostream>
#include<string>
using namespace std;
//设计一个学生类，属性有姓名和学号，可以给姓名和学号赋值，可以显示学生的姓名和学号。
//设计学生类
class Student
{
//1.类中的属性和行为，我们同意称之为 成员。
//属性： 我们又称之为：成员属性 或者成员变量。
//行为： 我们又称之为：成员函数 或者成员方法。
public : //公共权限
string m_Name; //属性
int m_Id; //属性
void showStudent()//行为输出学生的姓名
{
cout << "姓名:" << m_Name << "学号： " << m_Id << endl;
}
void setName(string name) //行为 更改姓名
{
m_Name = name;
}
void setnum(int m_Id1) //行为 更改学号
{
m_Id = m_Id1;
}
};
int main()
{
Student student1;
student1.m_Name = "chenxu";
student1.setName("zhangsan");
student1.m_Id = 1634130119;
student1.showStudent();
Student student2;
student2.m_Name = "nian";
student2.m_Id= 1634130137;
student2.setnum(12245465);
student2.showStudent();
system("pause");
return 0;
}
1.1.2将属性和行为加以权限控制。
类在设计的时候，可以把属性和行为放在不同的权限下，加以控制，访问权限有三种：
1.public 公共权限
2.protected 保护权限
3.private 私有权限
#include<iostream>
#include<string>
using namespace std;
//访问权限
//三种
//公共权限 public (成员（属性和行为）在类内可以访问，成员类外也可以访问)
//保护权限 protected (成员（属性和行为）在类内可以访问，成员类外不可以访问)-->（儿子可以访问父亲中的保护内容）
//私有权限 private (成员（属性和行为）在类内可以访问，成员类外不可以访问)-->（儿子不可以访问父亲中的私有内容）
// protected 和 private的区别主要体现在继承上。（继承的话，主要是父类和子类）
// 父亲的车子可以算是保护权限，儿子想开了，和父亲申请，开去吧
// 父亲的水杯可以算是私有权限，儿子想喝水（父亲有洁癖），申请，用你自己的去！！！
class person
{
//公共权限的成员
public :
string m_Name;
//保护权限
protected :
string m_Car;
//私有权限
private :
int m_Password;
public :
void func()
{
m_Name = "zhang san";
m_Car = "拖拉机";
m_Password = 123456;
cout << "姓名：" << m_Name << "车名：" << m_Car << "银行卡密码：" << m_Password << endl;
}
//在类内是不会报错的
};
int main()
{
//实力具体化
person p1;
p1.m_Name = "lisi";
// p1.m_Car= 这样写会出错哟，（保护权限类外不可以访问）
// p1.m_Password= 这样写也会出错哟，（私有权限类外不可以访问）
p1.func();
system("pause");
return 0;
}
1.2 struct和class的区别
在C++中 struct 和 class唯一的区别就在于 默认的访问方式不同
区别：
struct 的默认权限是公共权限
class的默认权限是私有权限
他们都是可以用来表示类。
#include<iostream>
#include<string>
using namespace std;
// struct 和 class 的区别
// struct默认的权限是 公共 public
// class 默认的权限是 私有 private
class C1
{
int m_A; //默认权限是 私有
};
struct C2
{
int m_A; //默认权限是 公共
};
int main()
{
C1 C123;
// C123.m_A = 123; 这样写会报错，原因就是他的权限是私有权限
C2 C1234;
C1234.m_A = 123;
system("pause");
return 0;
}
1.3 成员属性设置为私有
优点1：将所有的成员属性设置为私有，可以自己控制读写权限
优点2：对于读写权限，我们可以检测数据的有效性
#include<iostream>
#include<string>
using namespace std;
// 成员属性设置为私有
//1. 可以自己控制读写的权限 （很方便的控制可读写的权限）
//2. 对于写可以检测数据的有效性
//设计人的类
class Person
{
public:
//写姓名
void set_name(string name)
{
m_Name = name;
}
//读姓名
string get_name()
{
return m_Name;
}
//读年龄
int get_Age()
{
m_Age = 23;
return m_Age;
}
//只写名字
void set_m_Love(string name)
{
m_Love = name;
}
//获取情人年龄，可读可写，如果想修改（ 年龄的范围必须是 17-22 ）
//年龄的范围必须是一个正常的有效的范围，才可以。如果不是只能是初始的年龄
void set_m_lova_Age(int age)
{
if (age < 17 || age>22)
{
cout << "不在年龄范围内" << endl;
m_love_Age = 21;
return;
}
m_love_Age = age;
cout << "年龄修改成功" << endl;
}
int get_m_lova_Age()
{
return m_love_Age;
}
private :
string m_Name; //姓名 可读可写
int m_Age; //年龄 只读
int m_love_Age; //情人的年龄 可读写但是年龄要有范围。
string m_Love; //情人 只写
};
int main()
{
Person people;
people.set_name("张三");
cout<<"姓名为："<<people.get_name()<<endl;
cout << "年龄为：" << people.get_Age() << endl;
people.set_m_Love("苍井女士"); //只能进行写的权限，但是从外界是不可以进行访问的。
people.set_m_lova_Age(25);
people.set_m_lova_Age(19);
cout << "情人的年龄为：" << people.get_m_lova_Age() << endl;
system("pause");
return 0;
}
1.4 练习案例1：设计立方体
设计立方体类（Cube）
1.求出立方体的面积和体积
2.分别用 全局函数 和 成员函数 判断两个立方体是否相等（立方体的长宽高分别相等）
#include<iostream>
#include<string>
using namespace std;
//立方体类设计
//1. 创建一个立方体的类
//2. 设计属性和行为
//3. 获取到立方体的面积和体积
//4. 分别利用全局函数和成员函数，判断两个立方体是否相等。
class Cube
{
public:
//设置长
void setL(int L)
{
m_L = L;
}
//获取长
int Get_L()
{
return m_L;
}
//设置宽
void setW(int W)
{
m_W = W;
}
//获取宽
int Get_W()
{
return m_W;
}
//设置高
void setH(int H)
{
m_H = H;
}
//获取高
int Get_H()
{
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 isSamebyclass(Cube &c)
{
if (m_L == c.Get_L() && m_W == c.Get_H() && m_H == c.Get_W())
{
return true;
}
else
return false;
}
//设计属性
private:
int m_L;
int m_W;
int m_H;
};
//利用全局函数判断 两个立方体是不是相等
bool isSame(Cube &c1, Cube &c2)
{
if (c1.Get_L() == c2.Get_L() && c1.Get_H() == c2.Get_H() && c1.Get_W() == c2.Get_W())
{
return true;
}
else
return false;
}
int main()
{
//创建一个立方体对象C1
Cube C1;
C1.setL(10);
C1.setW(10);
C1.setH(10);
cout << "C1的面积为：" << C1.calculateS() << endl;
cout << "C1的体积为：" << C1.calculateV() << endl;
//创建另外的一个立方体对象C2
Cube C2;
C2.setL(10);
C2.setW(10);
C2.setH(10);
bool ret= isSame(C1, C2);
if (ret == true)
{
cout << "两个圆相等！！" << endl;
}
else
{
cout << "两个圆并不相等！！" << endl;
}
ret =C1.isSamebyclass(C2);
if (ret == true)
{
cout << "两个圆相等！！通过类内访问" << endl;
}
else
{
cout << "两个圆并不相等！！通过类内访问！" << endl;
}
system("pause");
return 0;
}
1.5 练习案例2：点和圆的关系
点和圆的关系重点在于
- 一个类中可以包含另外一个类
- 在代码中可以开始写多.cpp文件和.h文件了
- 可以开始写：： 哈哈，上午还在问这个是啥！！！
- 这个代码比较长，整体的代码，我放在这个连接了。
494
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
