• 第十二章 类和对象——封装

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

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

    例如：

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

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

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

    一、封装的意义

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

    封装的意义：

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

    • 将属性和行为加以权限控制

    封装意义一：

    在设计类的时候，属性和行为写在一起，表现事物

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

    示例1：设计一个圆类，求圆的周长

    示例代码：

    1.  //圆周率
    2.  const double PI = 3.14;
    3.  ​
    4.  //1、封装的意义
    5.  //将属性和行为作为一个整体，用来表现生活中的事物
    6.  ​
    7.  //封装一个圆类，求圆的周长
    8.  //class代表设计一个类，后面跟着的是类名
    9.  class Circle
    10.  {
    11.  public:  //访问权限  公共的权限
    12.  ​
    13.      //属性
    14.      int m_r;//半径
    15.  ​
    16.      //行为
    17.      //获取到圆的周长
    18.      double calculateZC()
    19.      {
    20.          //2 * pi  * r
    21.          //获取圆的周长
    22.          return  2 * PI * m_r;
    23.      }
    24.  };
    25.  ​
    26.  int main() {
    27.  ​
    28.      //通过圆类，创建圆的对象
    29.      // c1就是一个具体的圆
    30.      Circle c1;
    31.      c1.m_r = 10; //给圆对象的半径 进行赋值操作
    32.  ​
    33.      //2 * pi * 10 = = 62.8
    34.      cout << "圆的周长为： " << c1.calculateZC() << endl;
    35.  ​
    36.      system("pause");
    37.  ​
    38.      return 0;
    39.  }

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

    示例2代码：  ​

    1.  //学生类
    2.  class Student {
    3.  public:
    4.      void setName(string name) {
    5.          m_name = name;
    6.      }
    7.      void setID(int id) {
    8.          m_id = id;
    9.      }
    10.  ​
    11.      void showStudent() {
    12.          cout << "name:" << m_name << " ID:" << m_id << endl;
    13.      }
    14.  public:
    15.      string m_name;
    16.      int m_id;
    17.  };
    18.  ​
    19.  int main() {
    20.  ​
    21.      Student stu;
    22.      stu.setName("德玛西亚");
    23.      stu.setID(250);
    24.      stu.showStudent();
    25.  ​
    26.      system("pause");
    27.  ​
    28.      return 0;
    29.  }

    封装意义二：

    类在设计时，可以把属性和行为放在不同的权限下，加以控制

    访问权限有三种：

    1. public 公共权限

    2. protected 保护权限

    3. private 私有权限

    示例：

    1.  //三种权限
    2.  //公共权限  public     类内可以访问  类外可以访问
    3.  //保护权限  protected  类内可以访问  类外不可以访问
    4.  //私有权限  private    类内可以访问  类外不可以访问
    5.  ​
    6.  class Person
    7.  {
    8.      //姓名  公共权限
    9.  public:
    10.      string m_Name;
    11.  ​
    12.      //汽车  保护权限
    13.  protected:
    14.      string m_Car;
    15.  ​
    16.      //银行卡密码  私有权限
    17.  private:
    18.      int m_Password;
    19.  ​
    20.  public:
    21.      void func()
    22.      {
    23.          m_Name = "张三";
    24.          m_Car = "拖拉机";
    25.          m_Password = 123456;
    26.      }
    27.  };
    28.  ​
    29.  int main() {
    30.  ​
    31.      Person p;
    32.      p.m_Name = "李四";
    33.      //p.m_Car = "奔驰";  //保护权限类外访问不到
    34.      //p.m_Password = 123; //私有权限类外访问不到
    35.  ​
    36.      system("pause");
    37.  ​
    38.      return 0;
    39.  }

    二、struct和class区别

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

    区别：

    • struct 默认权限为公共

    • class 默认权限为私有

    1.  class C1
    2.  {
    3.      int  m_A; //默认是私有权限
    4.  };
    5.  ​
    6.  struct C2
    7.  {
    8.      int m_A;  //默认是公共权限
    9.  };
    10.  ​
    11.  int main() {
    12.  ​
    13.      C1 c1;
    14.      c1.m_A = 10; //错误，访问权限是私有
    15.  ​
    16.      C2 c2;
    17.      c2.m_A = 10; //正确，访问权限是公共
    18.  ​
    19.      system("pause");
    20.  ​
    21.      return 0;
    22.  }

    三、成员属性设置为私有

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

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

    示例：

    1.  class Person {
    2.  public:
    3.  ​
    4.      //姓名设置可读可写
    5.      void setName(string name) {
    6.          m_Name = name;
    7.      }
    8.      string getName()
    9.      {
    10.          return m_Name;
    11.      }
    12.  ​
    13.  ​
    14.      //获取年龄 
    15.      int getAge() {
    16.          return m_Age;
    17.      }
    18.      //设置年龄
    19.      void setAge(int age) {
    20.          if (age < 0 || age > 150) {
    21.              cout << "你个老妖精!" << endl;
    22.              return;
    23.          }
    24.          m_Age = age;
    25.      }
    26.  ​
    27.      //情人设置为只写
    28.      void setLover(string lover) {
    29.          m_Lover = lover;
    30.      }
    31.  ​
    32.  private:
    33.      string m_Name; //可读可写  姓名
    34.      
    35.      int m_Age; //只读  年龄
    36.  ​
    37.      string m_Lover; //只写  情人
    38.  };
    39.  ​
    40.  ​
    41.  int main() {
    42.  ​
    43.      Person p;
    44.      //姓名设置
    45.      p.setName("张三");
    46.      cout << "姓名： " << p.getName() << endl;
    47.  ​
    48.      //年龄设置
    49.      p.setAge(50);
    50.      cout << "年龄： " << p.getAge() << endl;
    51.  ​
    52.      //情人设置
    53.      p.setLover("苍井");
    54.      //cout << "情人： " << p.m_Lover << endl;  //只写属性，不可以读取
    55.  ​
    56.      system("pause");
    57.  ​
    58.      return 0;
    59.  }

    练习案例1：设计立方体类

    设计立方体类(Cube)

    求出立方体的面积和体积

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

                                            

    1. #include
    2. using namespace std;
    3.  
    4. class Cube
    5. {
    6.     private:
    7.         int m_l;
    8.         int m_w;
    9.         int m_h;
    10.     public:
    11.         // setter and getter
    12.         void setL(int l)
    13.         {
    14.             m_l = l;
    15.         }
    16.         int getL()
    17.         {
    18.             return m_l;
    19.         }
    20.         void setW(int w)
    21.         {
    22.             m_w = w;
    23.         }
    24.         int getW()
    25.         {
    26.             return m_w;
    27.         }
    28.         void setH(int h)
    29.         {
    30.             m_h = h;
    31.         }
    32.         int getH()
    33.         {
    34.             return m_h;
    35.         }
    36.  
    37.         // 获取周长
    38.         int getPerimeter()
    39.         {
    40.             return 2 * m_l * m_w + 2 * m_l * m_h + 2 * m_w * m_h;
    41.         }
    42.  
    43.         // 获取体积
    44.         int getVolume()
    45.         {
    46.             return m_l * m_w * m_h;
    47.         }
    48.  
    49.         // 判断相等
    50.         bool isSame(Cube &c)
    51.         {
    52.             return m_l == c.getL() && m_w == c.getW() && m_h == c.getH();
    53.         }
    54.  
    55.  
    56.  
    57. };
    58. bool isSame(Cube &c1, Cube &c2)
    59. {
    60.     return c1.getL() == c2.getL() && c1.getW() == c2.getW() && c1.getH() == c2.getH();
    61. }
    62. int main()
    63. {
    64.     
    65.     return 0;
    66. }

    练习案例2：点和圆的关系

    设计一个圆形类（Circle），和一个点类（Point），计算点和圆的关系。

                    ​​​​​​​        ​​​​​​​        ​​​​​​​

    法一：在一个文件中编写类的代码

    1. #include
    2. using namespace std;
    3.  
    4. class Pointer
    5. {
    6.     private:
    7.         int m_x;
    8.         int m_y;
    9.     public:
    10.         void setX(int x)
    11.         {
    12.             m_x = x;
    13.         }
    14.         int getX()
    15.         {
    16.             return m_x;
    17.         }
    18.         void setY(int y)
    19.         {
    20.             m_y = y;
    21.         }
    22.         int getY()
    23.         {
    24.             return m_y;
    25.         }
    26. };
    27.  
    28. class Circle
    29. {
    30.     private:
    31.         int m_r;
    32.         Pointer m_center;
    33.     public:
    34.         void setR(int r)
    35.         {
    36.             m_r = r;
    37.         }
    38.         int getR()
    39.         {
    40.             return m_r;
    41.         }
    42.         void setCenter(Pointer center)
    43.         {
    44.             m_center = center;
    45.         }
    46.         Pointer getCenter()
    47.         {
    48.             return m_center;
    49.         }
    50. };
    51.  
    52. void position(Circle circle, Pointer p)
    53. {
    54.     int distance = 
    55.         (p.getX() - circle.getCenter().getX()) * (p.getX() - circle.getCenter().getX()) + 
    56.         (p.getY() - circle.getCenter().getY()) * (p.getY() - circle.getCenter().getY());
    57.     int r = circle.getR() * circle.getR();
    58.  
    59.     if(distance <= r)
    60.     {
    61.         cout << "点在圆上！" << endl;
    62.     }
    63.     else
    64.     {
    65.         cout << "点在圆外！" << endl;
    66.     }
    67. }
    68.  
    69. int main()
    70. {
    71.     Pointer center;
    72.     center.setX(10);
    73.     center.setY(0);
    74.  
    75.     Circle circle;
    76.     circle.setR(10);
    77.     circle.setCenter(center);
    78.  
    79.     Pointer p;
    80.     p.setX(10);
    81.     p.setY(11);
    82.  
    83.     position(circle, p);
    84.  
    85.     return 0;
    86. }

    法二：分文件编写类的代码

    circle.h

    1. #pragma once
    2. #include
    3. #include"pointer.h"
    4. using namespace std;
    5.  
    6. class Circle
    7. {
    8.     private:
    9.         int m_r;
    10.         Pointer m_center;
    11.     public:
    12.         void setR(int r);
    13.         int getR();
    14.         void setCenter(Pointer center);
    15.         Pointer getCenter();
    16. };

    pointer.h

    1. #pragma once
    2. #include
    3. using namespace std;
    4. class Pointer
    5. {
    6.     private:
    7.         int m_x;
    8.         int m_y;
    9.     public:
    10.         void setX(int x);
    11.         int getX();
    12.         void setY(int y);
    13.         int getY();
    14. };

    circle.cpp

    1. #include "pointer.h"
    2. #include "circle.h"
    3.  
    4. void Circle::setR(int r)
    5. {
    6.     m_r = r;
    7. }
    8. int Circle::getR()
    9. {
    10.     return m_r;
    11. }
    12. void Circle::setCenter(Pointer center)
    13. {
    14.     m_center = center;
    15. }
    16. Pointer Circle::getCenter()
    17. {
    18.     return m_center;
    19. }

    pointer.cpp

    1. #include "pointer.h"
    2.  
    3. void Pointer::setX(int x)
    4. {
    5.     m_x = x;
    6. }
    7. int Pointer::getX()
    8. {
    9.     return m_x;
    10. }
    11. void Pointer::setY(int y)
    12. {
    13.     m_y = y;
    14. }
    15. int Pointer::getY()
    16. {
    17.     return m_y;
    18. }

    测试程序classTest.cpp

    1. #include "circle.h"
    2. void position(Circle circle, Pointer p)
    3. {
    4.     int distance = 
    5.         (p.getX() - circle.getCenter().getX()) * (p.getX() - circle.getCenter().getX()) + 
    6.         (p.getY() - circle.getCenter().getY()) * (p.getY() - circle.getCenter().getY());
    7.     int r = circle.getR() * circle.getR();
    8.  
    9.     if(distance <= r)
    10.     {
    11.         cout << "点在圆上！" << endl;
    12.     }
    13.     else
    14.     {
    15.         cout << "点在圆外！" << endl;
    16.     }
    17. }
    18.  
    19. int main()
    20. {
    21.     Pointer center;
    22.     center.setX(10);
    23.     center.setY(0);
    24.  
    25.     Circle circle;
    26.     circle.setR(10);
    27.     circle.setCenter(center);
    28.  
    29.     Pointer p;
    30.     p.setX(10);
    31.     p.setY(10);
    32.  
    33.     position(circle, p);
    34.  
    35. 	system("pause");
    36.     return 0;
    37. }

  • 相关阅读:
    聊聊不是产品经理的程序员如何做产品经理
    校园篮球网页作业成品 运动系列NBA篮球主题 学校篮球网页制作模板 学生简单体育运动网站设计成品
    superset连接Apache Spark SQL（hive）过程中的各种报错解决
    JavaWeb核心篇（3）——JSP，MVC，三层架构
    通过 Elasticsearch 和 Go 使用混合搜索进行地鼠狩猎
    STM32--人体红外感应开关
    Hadoop单个节点的磁盘均衡
    Modbus协议详解4：RTU帧 & ASCII帧的差错校验
    SpringAMQP
    ENSP交换机接口trunk和access互改
  • 原文地址：https://blog.csdn.net/qq_26126363/article/details/133419444