• C++核心编程之类和对象---C++面向对象的三大特性--封装

    目录

    类和对象

    类和对象的概念

    C++面向对象的三大特性

    一、封装

    封装案例1：设计一个学生类，可以给姓名和学号赋值，可以显示学生的姓名和学号。

    二、访问权限

    访问权限有三种

    struct和class的区别

    三、成员属性私有化

    成员属性私有化的优点：

    四、封装案例

    案例1：设计立方体类

    案例2：点和圆的关系

    类和对象

    面向对象编程（OOP）是现代编程的基石之一。C++是一种支持OOP的语言，允许你创建类（Class）和对象（Object）。

    类和对象的概念

    1. 类是对对象的抽象。类是一种抽象的数据类型。它们的关系是，对象是类的实例，类是对象的模板。对象是通过new className产生的，用来调用类的方法;类的构造方法 。

    2. 类的意义:

      2-1.类是把属性和方法进行封装，同时对类的属性和方法进行访问控制。

      2-2.类是由我们根据客观事物抽象而成，形成一类事物，然后用类去定义对象，形成这类事物的具体个体。

      2-3.类是一个数据类型，类是抽象的，而对象是一个具体的变量，是占用内存空间的。

    3. 类的访问控制

      在C++中可以对类的属性和方法定义访问级别，public修饰的属性和方法，可以在类的内部访问，也可以在类的外部进行访问。private修饰的属性和方法，只能在类的内部进行访问。

    4. 行为

      所有对象公有操作即成员函数（通常习惯为public属性）属性：所有对象公有特性即数据成员（通常习惯为protected属性）

    C++面向对象的三大特性

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

    封装目的是实现代码模块化，继承目的是实现代码扩展，静态多态的目的是函数重载和泛型编程，动态多态的目的是虚函数重写。

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

    例如:

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

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

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

    一、封装

    封装是C++面向对象的三大特性之一，封装就是将数据和行为有机结合起来，形成一个整体。把数据和处理数据的操作结合形成类，数据和函数都是类的成员。

    1.封装的意义：

    • 将属性和行为作为一个整体，表现生活中的事务
    • 将属性和行为加以权限控制

    2.语法：

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

    示例：通过一个圆类中的行为得到圆的周长

    1. #include
    2.  
    3. #include
    4.  
    5. using namespace std;
    6.  
    7. // 圆周率
    8.  
    9. const double PI = 3.14;
    10.  
    11. // 设计一个圆类   求圆的周长
    12.  
    13. // class（一个类） 类名
    14.  
    15. // class代表设计一个类，类后面紧跟着的就是类的名称
    16.  
    17. class circle {
    18.  
    19.     // 访问权限
    20.  
    21.     // 公共权限
    22.  
    23. public:
    24.  
    25.     // 属性
    26.  
    27.     // 半径
    28.  
    29.     int r;
    30.  
    31.     //行为：一般为函数
    32.  
    33.     // 获取周长
    34.  
    35.     double calculateZC()
    36.  
    37.     {
    38.  
    39.         return 2 * PI * r;
    40.  
    41.     }
    42.  
    43. };
    44.  
    45.  
    46.  
    47. int main()
    48.  
    49. {
    50.  
    51.     // 通过圆类创建具体的圆（对象）
    52.  
    53.     // 实例化   ( 通过一个类  创建一个对象的过程 )
    54.  
    55.     circle c1;
    56.  
    57.     // 给圆对象 的属性进行赋值
    58.  
    59.     c1.r = 10;
    60.     
    61.     cout << "圆的周长：" << c1.calculateZC() << endl;
    62.  
    63.     return 0;
    64.  
    65. }

    运行结果：

    ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

    封装案例1：设计一个学生类，可以给姓名和学号赋值，可以显示学生的姓名和学号。

    1. #include
    2.  
    3. #include
    4.  
    5. using namespace std;
    6.  
    7. // 设计一个学生类，属性有姓名和学号
    8.  
    9. // 可以给姓名和学号赋值，可以显示学生的姓名和学号
    10.  
    11. // 设计学生类
    12.  
    13. class student {
    14.  
    15. public:  // 公共权限
    16.  
    17.  
    18.  
    19.     // 类中的属性和行为  我们统一称为  成员
    20.  
    21.     // 属性  成员属性   成员变量
    22.  
    23.     // 行为  成员函数   成员方法
    24.  
    25.  
    26.  
    27.     // 属性
    28.  
    29.     string name;
    30.  
    31.     int id;
    32.  
    33.  
    34.  
    35.     // 行为
    36.  
    37.     // 显示姓名与学号
    38.  
    39.     void showstu()
    40.  
    41.     {
    42.  
    43.         cout << "姓名: " << name << "  学号: " << id << endl;
    44.  
    45.     }
    46.  
    47.  
    48.  
    49.     // 可以通过对象的行为给属性赋值
    50.  
    51.     void setname(string i_name)
    52.  
    53.     {
    54.  
    55.         name = i_name;
    56.  
    57.     }
    58.  
    59.     void setID(int i_id)
    60.  
    61.     {
    62.  
    63.         id=i_id;
    64.  
    65.     }
    66.  
    67. };
    68.  
    69. int main()
    70.  
    71. {
    72.  
    73.     // 创建一个具体的学生
    74.  
    75.     // 实例化对象
    76.  
    77.     class student s1;
    78.  
    79.     // 给s1属性赋值
    80.  
    81.     s1.setname("张三");
    82.  
    83.     s1.id = 01;
    84.  
    85.     s1.showstu();
    86.  
    87.  
    88.  
    89.     class student s2;
    90.  
    91.     // 给s2属性赋值
    92.  
    93.     s2.name = "李四";
    94.  
    95.     s2.id = 02;
    96.  
    97.     s2.showstu();
    98.  
    99.  
    100.  
    101.     class student s3;
    102.  
    103.     // 通过对象的行为给属性赋值
    104.  
    105.     s3.setname("王五");
    106.  
    107.     s3.setID(03);
    108.  
    109.     s3.showstu();
    110.  
    111.     return 0;
    112.  
    113. }

     

    运行结果：

     

    二、访问权限

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

    访问权限有三种

     1. public          公共权限                成员 类内类外都可以访问

     2. protected   保护权限                成员 类内可以访问，类外不可以访问（有继承关系，父子关系）

     3. private            私有权限                成员 类内可以访问，类外不可以访问（父子关系也不可以访问）

    示例：

    1. #include
    2.  
    3. using namespace std;
    4.  
    5. class person{
    6.  
    7. public:
    8.  
    9.     // 公共权限
    10.  
    11.     string name;
    12.  
    13.  
    14.  
    15. protected:
    16.  
    17.     // 保护权限
    18.  
    19.     string car;
    20.  
    21.  
    22.  
    23. private:
    24.  
    25.     // 私有权限
    26.  
    27.     int password;
    28.  
    29.  
    30.  
    31. public:
    32.  
    33.     void fun()
    34.  
    35.     {
    36.  
    37.         name = "张三";
    38.  
    39.         car = "BMW";
    40.  
    41.         password = 123456;
    42.  
    43.     }
    44.  
    45.     // 不管哪种形式在类内都是可以访问的
    46.  
    47. };
    48.  
    49. int main ()
    50.  
    51. {
    52.  
    53.     // 实例化具体的对象
    54.  
    55.     class person p1;
    56.  
    57.     p1.name = "李四";
    58.  
    59.  
    60.  
    61.     p1.car = "AMG";  // 保护权限的内容在类外是不能访问的
    62.  
    63.  
    64.  
    65.     p1.password = 258258; // 私有权限的内容在类外是不能访问的
    66.  
    67.     return 0;
    68.  
    69. }

     

    报错显示：

     

    struct和class的区别

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

    区别：

     struct 默认是公共权限

     class 默认是私有权限

     

    示例：

    1. #include
    2.  
    3. using namespace std;
    4.  
    5. class C1
    6. {
    7.  
    8.     int m_A;// 默认权限   是私有
    9.  
    10. };
    11.  
    12. struct C2
    13. {
    14.  
    15.     int m_A;// 默认权限  是公共
    16.  
    17. };
    18.  
    19. int main ()
    20.  
    21. {
    22.  
    23.     class C1 c1;
    24.  
    25.     c1.m_A=1000;
    26.  
    27.     struct C2 c2;
    28.  
    29.     c2.m_A=100;
    30.  
    31.     return 0;
    32.  
    33. }

     

    报错显示：

     

    三、成员属性私有化

    成员属性私有化的优点：

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

     2. 对于写权限，可以检测数据的有效性

    示例：

    1. #include
    2.  
    3. #include
    4.  
    5. using namespace std;
    6.  
    7. // 设计一个人类
    8.  
    9. class person{
    10.  
    11.     // 设计一个public 的公共接口
    12.  
    13. public:
    14.  
    15.     // 设置姓名
    16.  
    17.     void set_name(string in_name)
    18.  
    19.     {
    20.  
    21.             name = in_name;
    22.  
    23.     }
    24.  
    25.     // 获取姓名
    26.  
    27.     string get_name()
    28.  
    29.     {
    30.  
    31.         return name;
    32.  
    33.     }
    34.  
    35.     // 设置年龄
    36.  
    37.     void set_age(int in_age)
    38.  
    39.     {
    40.  
    41.         if(in_age<=0||in_age>150){
    42.  
    43.             cout<<"你输入的年龄有误!"<
    44.  
    45.             return;
    46.  
    47.         }
    48.  
    49.         age=in_age;
    50.  
    51.     }
    52.  
    53.     // 获取年龄
    54.  
    55.     int get_age()
    56.  
    57.     {
    58.  
    59.         return age;
    60.  
    61.     }
    62.  
    63.     // 设置情人，只写
    64.  
    65.     void set_lover(string in_lover)
    66.  
    67.     {
    68.  
    69.         lover = in_lover;
    70.  
    71. }
    72.  
    73. private:
    74.  
    75.     // 姓名  可读可写
    76.  
    77.     string name;
    78.  
    79.  
    80.  
    81.     // 年龄        可读可写
    82.  
    83.     int age = 0;
    84.  
    85.  
    86.  
    87.     // 情人        只写
    88.  
    89.     string lover;
    90.  
    91. };
    92.  
    93. int main()
    94.  
    95. {
    96.  
    97.     class person p1;
    98.  
    99.     p1.set_name("张三");
    100.  
    101.     cout<<"姓名为: "<get_name()<
    102.  
    103.     p1.set_age(200);
    104.  
    105.     cout<<"年龄为: "<get_age()<
    106.  
    107.     p1.set_lover("鞠婧祎");
    108.  
    109.     return 0;
    110.  
    111. }

    运行结果：

    四、封装案例

    案例1：设计立方体类

    设计立方体类（Cube）

    求出立方体的面积和体积

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

    示例：

    1. #include
    2.  
    3. #include
    4.  
    5. using namespace std;
    6.  
    7. /*
    9. 1.创建立方体类
    11. 2.设计属性
    13. 3.设计行为  获取立方体面积和体积
    15. 4.分别利用全局函数和成员函数  判断两个立方体是否相等
    17. */
    18.  
    19. // 立方体类
    20.  
    21. class Cube{
    22.  
    23. public:
    24.  
    25.     void setL(int L)
    26.  
    27.     {
    28.  
    29.         m_L=L;
    30.  
    31.     }
    32.  
    33.     int getL()
    34.  
    35.     {
    36.  
    37.         return m_L;
    38.  
    39.     }
    40.  
    41.     void setW(int W)
    42.  
    43.     {
    44.  
    45.         m_W=W;
    46.  
    47.     }
    48.  
    49.     int getW()
    50.  
    51.     {
    52.  
    53.         return m_W;
    54.  
    55.     }
    56.  
    57.  
    58.  
    59.     void setH(int H)
    60.  
    61.     {
    62.  
    63.         m_H=H;
    64.  
    65.     }
    66.  
    67.     int getH()
    68.  
    69.     {
    70.  
    71.         return m_H;
    72.  
    73.     }
    74.  
    75.  
    76.  
    77.     // 获取立方体的面积
    78.  
    79.     int calculateS()
    80.  
    81.     {
    82.  
    83.         return 2*(m_L*m_W+m_W*m_H+m_L*m_H);
    84.  
    85.     }
    86.  
    87.     // 获取立方体的体积
    88.  
    89.     int calculateV()
    90.  
    91.     {
    92.  
    93.         return m_L*m_H*m_W;
    94.  
    95.     }
    96.  
    97.    
    98.  
    99.     // 利用成员函数判断两个立方体是否相等
    100.  
    101.     bool isSameByClass(Cube &C)
    102.  
    103.     {
    104.  
    105.         if(m_L==C.getL()&&m_W==C.getW()&&m_H==C.getH()){
    106.  
    107.             return true;
    108.  
    109.         }
    110.  
    111.         return false;
    112.  
    113.     }
    114.  
    115. private:
    116.  
    117.     int m_L;// 长
    118.  
    119.     int m_W;// 宽
    120.  
    121.     int m_H;// 高
    122.  
    123. };
    124.  
    125. // 利用全局函数判断  两个立方体是否相等
    126.  
    127. bool isSame(Cube &C1,Cube &C2)
    128.  
    129. {
    130.  
    131.     if(C1.getL()==C2.getL()&&C1.getW()==C2.getW()&&C1.getH()==C2.getH()){
    132.  
    133.         return true;
    134.  
    135.     }
    136.  
    137.     return false;
    138.  
    139. }
    140.  
    141. int main()
    142.  
    143. {
    144.  
    145.     // 创建一个立方体对象
    146.  
    147.     class Cube C1;
    148.  
    149.     C1.setL(10);
    150.  
    151.     C1.setW(10);
    152.  
    153.     C1.setH(10);
    154.  
    155.     cout<<"C1的面积为："<calculateS()<
    156.  
    157.     cout<<"C1的体积为："<calculateV()<
    158.  
    159.  
    160.  
    161.     // 创建第二个立方体
    162.  
    163.     class Cube C2;
    164.  
    165.     C2.setL(10);
    166.  
    167.     C2.setW(20);
    168.  
    169.     C2.setH(10);
    170.  
    171.  
    172.  
    173.     // 全局函数判断
    174.  
    175.     bool ret=isSame(C1,C2);
    176.  
    177.     if(ret){
    178.  
    179.         cout<<"C1和C2是相等的"<
    180.  
    181.     }
    182.  
    183.     else{
    184.  
    185.         cout<<"C1和C2是不相等的"<
    186.  
    187.     }
    188.  
    189.  
    190.  
    191.     // 成员函数判断
    192.  
    193.     ret=C1.isSameByClass(C2);
    194.  
    195.     if(ret){
    196.  
    197.         cout<<"成员函数判断：C1和C2是相等的"<
    198.  
    199.     }
    200.  
    201.     else{
    202.  
    203.         cout<<"成员函数判断：C1和C2是不相等的"<
    204.  
    205.     }
    206.  
    207.     return 0;
    208.  
    209. }

    运行结果：

    案例2：点和圆的关系

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

    示例：

    1. #include
    2.  
    3. #include
    4.  
    5. #include
    6.  
    7. using namespace std;
    8.  
    9. // 判断点和圆的关系
    10.  
    11. /*
    13. 点到圆心的距离== 半径  点在圆上
    15. 点到圆心的距离 > 半径  点在圆外
    17. 点到圆心的距离 < 半径  点在圆内
    19. */
    20.  
    21. class Point
    22.  
    23. {
    24.  
    25. public:
    26.  
    27.     void setX(int X)
    28.  
    29.     {
    30.  
    31.         m_X=X;
    32.  
    33.     }
    34.  
    35.     int getX()
    36.  
    37.     {
    38.  
    39.         return m_X;
    40.  
    41.     }
    42.  
    43.     void setY(int Y)
    44.  
    45.     {
    46.  
    47.         m_Y=Y;
    48.  
    49.     }
    50.  
    51.     int getY()
    52.  
    53.     {
    54.  
    55.         return m_Y;
    56.  
    57.     }
    58.  
    59. private:
    60.  
    61.     int m_X;
    62.  
    63.     int m_Y;
    64.  
    65. };
    66.  
    67. class Circle
    68.  
    69. {
    70.  
    71. public:
    72.  
    73.     // 设置半径
    74.  
    75.     void setR(int R)
    76.  
    77.     {
    78.  
    79.         m_R=R;
    80.  
    81.     }
    82.  
    83.     int getR()
    84.  
    85.     {
    86.  
    87.         return m_R;
    88.  
    89.     }
    90.  
    91.     // 设置圆心
    92.  
    93.     void setCenter(Point center)
    94.  
    95.     {
    96.  
    97.         m_Center=center;
    98.  
    99.     }
    100.  
    101.     Point getCenter()
    102.  
    103.     {
    104.  
    105.         return m_Center;
    106.  
    107.     }
    108.  
    109. private:
    110.  
    111.     int m_R;  // 半径
    112.  
    113.     class Point m_Center;
    114.  
    115. };
    116.  
    117. // 判断点和圆的关系
    118.  
    119. void isInCircle(Circle &c,Point &p)
    120.  
    121. {
    122.  
    123.     // 计算两点间距离
    124.  
    125.     int distance=pow((pow(c.getCenter().getX()-p.getX(),2))+(pow(c.getCenter().getY()-        p.getY(),2)),0.5);
    126.  
    127.  
    128.  
    129.     if(distance==c.getR()){
    130.  
    131.         cout<<"点在圆上"<
    132.  
    133.     }else if(distance > c.getR()){
    134.  
    135.         cout<<"点在圆外"<
    136.  
    137.     }else{
    138.  
    139.         cout<<"点在圆内"<
    140.  
    141.     }
    142.  
    143. }
    144.  
    145. int main()
    146.  
    147. {
    148.  
    149.     // 创建一个圆  和一个圆心  的对象
    150.  
    151.     Circle c;
    152.  
    153.     c.setR(10);
    154.  
    155.     Point center;
    156.  
    157.     center.setX(10);
    158.  
    159.     center.setY(0);
    160.  
    161.     c.setCenter(center);
    162.  
    163.  
    164.  
    165.     // 创建一个点
    166.  
    167.     Point P;
    168.  
    169.     P.setX(10);
    170.  
    171.     P.setY(9);
    172.  
    173.  
    174.  
    175.     // 全局函数判断点和圆的位置关系
    176.  
    177.     isInCircle(c,P);
    178.  
    179.     return 0;
    180.  
    181. }

    运行结果：

  • 相关阅读:
    Redis常用数据结构操作与底层原理
    解读OpenShift的逻辑架构和技术架构
    Java中的自定义异常
    3D-2D PNP
    MySQL 从一个表中查出数据并插入到另一个表处理方案（详细）
    2022-vue实现-“对象数组“-模糊搜索功能
    layui laydate 提示“日期格式不正确”
    Web3D虚拟人制作简明指南
    动态数据渲染订单查询实现
    Java 类之 java.lang.reflect.Method
  • 原文地址：https://blog.csdn.net/hjl011006/article/details/132915055