C++学习日记---第13天（类和对象---封装）

条记复习

1.类和对象

c++面向对象的三大特性为：封装，继续，多态
c++以为万事万物都皆为对象，对象上有其属性和举动
具有类似性子的对象，我们可以抽象为称为类
2.封装

作用：将属性和举动作为一个团体，体现生存中的事物，具有类似性子的对象，我们可以抽象为类。
语法：class 类名{访问权限（也可不写，默以为private）：属性/举动}；
示例：

2. class circle{
3. public:
4.     int m_r;
5.     double calculator(){
6.         return 2*pi*m_r;
7.     }
9. }

复制代码

封装案例：盘算一个圆的周长

2. #include<iostream>
3. using namespace std;
5. const double pi = 3.14;
6. class circle {
7. public:
8.         //属性
9.         //半径
10.         int m_r;
11.         //行为
12.         //获取圆的周长
13.         double calculatezc() {
14.                 return 2 * pi * m_r;
15.         }
16. };
18. int main() {
19. 通过圆类创建具体的圆（对象）
20.         circle c1;
21. 给圆对象的属性进行赋值操作
22.         c1.m_r = 10;
23.         cout << "圆的周长为" << c1.calculatezc() << endl;
24.         system("pause");
25.         return 0;
26. }

复制代码

对比结构体我们不难发现，类与结构体可以说千篇一律，但现实上类与结构体的区别很大，不外难度过高，我们这里不做深入探究，下面我们来学习类的访问权限
3.类的访问权限

1）分类

访问权限一共有一下三种：
a.public         公共权限                                            此中的成员类内可以访问，类外也可以访问
b.protected    掩护权限                                            此中的成员类内可以访问，类外不可以访问
对于protected权限，特定职员有权访问
c.private         私有权限                                           此中的成员类内可以访问，类外不可以访问
对于private权限，除本人外其他人无权访问
现实上在结构体struct中也有权限，不外与类class的区别是，struct的默认权限是公共权限，class的默认权限是私有权限
2）访问权限的作用

在现实的编程项目中，我们通常将类的对象的属性设置为私有，而类中的函数则设置为公有。
比方：

2. class student{
3. public:
4.     int let_you_see_it(){
5.         return age;
6. }
7. private:
8.     int age=18;
9. }

复制代码

利用这一利用，我们可以本身设置类对象属性的只读，只写，读写利用，代码如下：

2. #include<iostream>
3. #include<string>
4. using namespace std;
6. class person {//创建一个person结构体
7. public:
8.         void set_name(string name) {//定义一个函数来接收数据，然后将数据赋给私有权限中的数据
9.                 m_name = name;
10.                 //这个函数无返回值，故要返回字符串需要创建一个string函数
11.         }
12.         string get_name() {
13.                 return m_name;
14.         }
15.         int get_age() {
16.                 return m_age;//类内可以访问私有成员
17.         }
18.         void set_idol(string idol) {
19.                 m_idol = idol;//没有返回值，只写
20.         }
21. private:
22.         string m_name; //可读可写
23.         int m_age=18;//只读
24.         string m_idol;//只写
25. };
27. int main() {
28.         person p;
29.     //创建一个person中的p对象
30.         p.set_name("张三");
31.         cout << "姓名:" << p.get_name() << endl;
32.         cout << "年龄:" << p.get_age() << endl;
33.         p.set_idol("小明");
35.         system("pause");
36.         return 0;
37. }

复制代码

4.类案例：长方体类

案例要求：
1）创创建方体类
2）计划属性
3）计划举动，获取立方面子积和体积
4）分别利用全局函数和成员函数判定两个立方体是否相当
我们仍旧利用上面的方法，将属性设置为私有，并通过成员函数来修改和获取属性的值
我们将代码实现分为三个部门，第一部门是设置属性，完成面积体积的盘算，第二部门是用全局函数判定两个立方体是否相当，第三部门是用成员函数判定，下面给出第一部门的代码：

2. #include<iostream>
3. using namespace std;
5. class cube {
6. public:
7.         void set_l(int l) {
8.                 m_l = l;
9.         }
10.         int get_l() {
11.                 return m_l;
12.         }
13.         void set_w(int w) {
14.                 m_w = w;
15.         }
16.         int get_w() {
17.                 return m_w;
18.         }
19.         void set_h(int h) {
20.                 m_h = h;
21.         }
22.         int get_h() {
23.                 return m_h;
24.         }
25.         int calculateS() {
26.                 return 2 * m_l * m_w + 2 * m_w * m_h + 2 * m_l * m_h;
27.         }
28.         int calculateV() {
29.                 return m_l * m_w * m_h;
30.         }
31. private:
32.         int m_l;
33.         int m_w;
34.         int m_h;
35. };
37. int main() {
38.         cube c1;
39.         c1.set_l(10);
40.         c1.set_w(20);
41.         c1.set_h(30);
42.         cout <<"c1的面积为"<< c1.calculateS() << endl;
43.         cout <<"c1的体积为"<< c1.calculateV() << endl;
45.         return 0;
46. }

复制代码

第二部门代码为：

2. bool isSame1(cube& c1, cube& c2) {
3.         if (c1.get_l() == c2.get_l() && c1.get_w() == c2.get_w() && c1.get_h() == c2.get_h()) {
4.                 return true;
5.         }
6.         return false;
7. }

复制代码

第三部门代码为：

2. bool isSame2(cube& c) {
3.         //这里传递的参数一个就可以，因为我们是用已知的一个对象去调用未知的一个对象
4.         if (m_l == c.get_l() && m_w == c.get_w() && m_h == c.get_h()) {
5.                 return true;
6.         }
7.         return false;
8. }

复制代码

完备代码如下：

2. #include<iostream>
3. using namespace std;
5. class cube {
6. public:
7.         void set_l(int l) {
8.                 m_l = l;
9.         }
10.         int get_l() {
11.                 return m_l;
12.         }
13.         void set_w(int w) {
14.                 m_w = w;
15.         }
16.         int get_w() {
17.                 return m_w;
18.         }
19.         void set_h(int h) {
20.                 m_h = h;
21.         }
22.         int get_h() {
23.                 return m_h;
24.         }
25.         int calculateS() {
26.                 return 2 * m_l * m_w + 2 * m_w * m_h + 2 * m_l * m_h;
27.         }
28.         int calculateV() {
29.                 return m_l * m_w * m_h;
30.         }
31.         bool isSame2(cube& c) {
32.                 //这里传递的参数一个就可以，因为我们是用已知的一个对象去调用未知的一个对象
33.                 if (m_l == c.get_l() && m_w == c.get_w() && m_h == c.get_h()) {
34.                         return true;
35.                 }
36.                 return false;
37.         }
38. private:
39.         int m_l;
40.         int m_w;
41.         int m_h;
42. };
44. bool isSame(cube& c1, cube& c2) {
45.         if (c1.get_l() == c2.get_l() && c1.get_w() == c2.get_w() && c1.get_h() == c2.get_h()) {
46.                 return true;
47.         }
48.         return false;
49. }
51. int main() {
52.         cube c1;
53.         c1.set_l(10);
54.         c1.set_w(20);
55.         c1.set_h(30);
56.         cout <<"c1的面积为"<< c1.calculateS() << endl;
57.         cout <<"c1的体积为"<< c1.calculateV() << endl;
58.         cube c2;
59.         c2.set_l(10);
60.         c2.set_w(10);
61.         c2.set_h(30);
62.         cout << "c2的面积为" << c2.calculateS() << endl;
63.         cout << "c2的体积为" << c2.calculateV() << endl;
64.         bool ret1 = isSame(c1,c2);//引用传递
65.         if (ret1) {
66.                 cout << "全局函数：两个立方体相等" << endl;
67.         }
68.         else {
69.                 cout << "全局函数；两个立方体不相等" << endl;
70.         }
71.         bool ret2 = c1.isSame2(c2);
72.         //这里如果是用c1作为对象，那么传入c2即可，如果是c2作为对象，那么传入c1
73.         if (ret2) {
74.                 cout << "成员函数：两个立方体相等" << endl;
75.         }
76.         else {
77.                 cout << "成员函数；两个立方体不相等" << endl;
78.         }
80.         return 0;
81. }

复制代码