• C++第四章：类与对象

    一、面向对象程序设计的四个基本特点 

    1. 抽象 

            面向对象方法中的抽象，是指对具体问题（对象）进行概括，抽出 一类对象 的公共性质并加以描述的过程。 
            对一个问题的抽象应该包括两个方面：数据抽象和行为抽象（或称为功能抽象、代码抽象）。前者描述某类对象的属性或状态，也就是此类对象区别于彼类对象的特征；后者描述的是某类对象的共同行为或功能特征。

    例子：

    时钟
    数据抽象：int hour, int minute, int second；
    行为抽象：showTime()，setTime()；

    对人进行抽象
    共同的属性，数据抽象：string name, string sex, int age；
    共同的行为，行为抽象：eat(), walk(), work(), study()；

    2. 封装 

            封装就是将 抽象得到的 数据和行为（或功能）相结合，形成一个有机的整体，也就是将 数据 与 操作数据的函数代码 进行有机的结合，形成“类”，其中的数据和函数都是类的成员。

     例如：时钟类的定义如下：

    1. class Clock                      //class 关键字   类名
    2. {                                //边界
    3. public:                          //外部接口
    4.     void setTime(int newH, int newM, int newS);//行为，代码成员
    5.     void showTime();             //行为，代码成员
    6. private:                         //特定的访问权限
    7.     int hour, minute, second;    //属性，数据成员
    8. };                               //边界

            这里定义了一个名为Clock的类，其中的函数成员和数据成员，描述了抽象的结果。
    声明为 public 的两个函数为类提供了外部接口，外界只能通这个接口来与 Clock 类发生联系；
    声明为 private 的3个整型数据是本类的私有数据，外部无法直接访问。

    3. 继承

            C++语言中提供了类的继承机制，允许程序员在保持原有类特性的基础上，进行更具体、更详细的说明。通过类的这种层次结构，可以很好地反映出特殊概念与一般概念的关系。

    4. 多态 

            多态性是指一段程序 能够处理多种类型对象 的能力。在C++语言中，这种多态性可以通过强制多态、重载多态、类型参数化多态、包含多态4种形式来实现。

    • 强制多态是通过将一种类型的数据转换成另一种类型的数据来实现的，也就是前面介绍过的数据类型转换（隐式或显式）。
    • 重载是指给同一个名字赋予不同的含义，如上篇的函数重载。

    这两种多态属于特殊多态性，只是表面的多态性。

    • C++中采用虚函数实现包含多态。虚函数是多态性的精华。
    • 模板是C++实现参数化多态性的工具，分为函数模板和类模板两种。

    这两种多态属于一般多态性，是真正的多态性。

    二、类

    类的定义

    定义类的语法形式如下： 

    1. class 类名称
    2. {
    3. public:
    4.     外部接口
    5. protected:
    6.     保护型成员
    7. private:
    8.     私有成员
    9. }；

    类成员的访问控制：

        访问控制属性可以有以下3种：
        公有类型（public）、私有类型（private）和保护类型（protected）

    • 公有类型成员定义了类的外部接口，在类外只能访问类的公有成员；
    • 私有成员只能被本类的成员函数访问，来自类外部的任何访问都是非法的；
    • 保护类型成员的性质和私有成员的性质相似，其差别在于继承过程中对产生的新类影响不同。

    例子

    计算大圆减小圆面积 

    1. #include 
    2. //#include "func.h"
    3. using namespace std;
    4.  
    5. class Cirle
    6. {
    7. public:
    8.     void setRadius(double r)
    9.     {
    10.         radius = r;
    11.     }
    12.     double area()
    13.     {
    14.         return 3.1415*radius*radius;
    15.     }
    16. private:
    17.     double radius;
    18. };
    19.  
    20. int main()
    21. {
    22.     Cirle c1;
    23.     c1.setRadius(10);
    24.  
    25.     Cirle c2;
    26.     c2.setRadius(5);
    27.  
    28.     double ret;
    29.     ret = c1.area()-c2.area();
    30.     cout << ret << endl;
    31.  
    32.     cout << "Hello World!" << endl;
    33.     return 0;
    34. }

    带参： Clock a(1,2,3);

    1. class Clock
    2. {
    3. public:
    4.     Clock(int h = 0,int m = 0, int s = 0);
    5.  
    6.     void setTime(int h, int m, int s)
    7.     {
    8.         hour = h;
    9.         minute = m;
    10.         second = s;
    11.     }
    12.  
    13.     void showTime()
    14.     {
    15.         cout << hour << ":" << minute << ":" << second << endl;
    16.     }
    17. private:
    18.     int hour;
    19.     int minute;
    20.     int second;
    21. };
    22.  
    23. Clock::Clock(int h,int m,int s)
    24. {
    25.     hour = h;
    26.     minute = m;
    27.     second = s;
    28. }
    29.  
    30. int main()
    31. {
    32.     Clock a(1,2,3);
    33.     a.showTime();
    34.  
    35.     cout << "Hello World!" << endl;
    36.     return 0;
    37. }

     

     无参/用默认参数：调用时无括号-->Clock a;

    1.  
    2. int main()
    3. {
    4.     Clock a;
    5.     a.showTime();
    6.  
    7.     cout << "Hello World!" << endl;
    8.     return 0;
    9. }

    初始化列表

    初始化列表只能出现在构造函数中；

    1. class Clock
    2. {
    3. public:
    4.     Clock(int h = 0,int m = 0, int s = 0);
    5.  
    6.     void setTime(int h, int m, int s)
    7.     {
    8.         hour = h;
    9.         minute = m;
    10.         second = s;
    11.     }
    12.     void showTime()
    13.     {
    14.         cout << hour << ":" << minute << ":" << second << endl;
    15.     }
    16. private:
    17.     int hour;
    18.     int minute;
    19.     int second;
    20. };
    21.  
    22. Clock::Clock(int h,int m,int s): hour(h), minute(m), second(s)
    23. {
    24.  
    25. }

    虚数例子：

    my_complex.h

    1. #ifndef MY_COMPLEX_H
    2. #define MY_COMPLEX_H
    3. class Complex
    4. {
    5. public:
    6.     Complex(double r = 0,double i = 0);
    7.     void show();
    8.  
    9.  
    10.     void setReal(double r);
    11.  
    12.     void setImag(double i);
    13.  
    14. private:
    15.     double real;
    16.     double imag;
    17. };
    18. #endif // MY_COMPLEX_H

    my_complex.cpp

    1. #include "my_complex.h"
    2. #include 
    3. using namespace std;
    4. void Complex::show()
    5. {
    6.     cout << real << "+" << imag << "i" << endl;
    7. }
    8.  
    9. void Complex::setReal(double r)
    10. {
    11.     real = r;
    12. }
    13. void Complex::setImag(double i)
    14. {
    15.     imag = i;
    16. }
    17.  
    18. Complex::Complex(double r,  double i) : real(r), imag(i)
    19. {
    20.  
    21. }

    main.cpp

    1. #include 
    2. using namespace std;
    3. #include "my_complex.h"
    4. int main()
    5. {
    6.     Complex c1;
    7.     c1.setReal(1);
    8.     c1.setImag(2);
    9.     c1.show();
    10.     Complex c2(1.1,2.2);
    11.     c2.show();
    12.  
    13.     cout << "Hello World!" << endl;
    14.     return 0;
    15. }

    三、构造函数与析构函数

    构造函数 

            构造函数的作用就是在对象被创建时利用特定的值构造对象，将对象初始化为一个特定的状态。构造函数主要目的是为了初始化。

    特性 

    • 构造函数的函数名与类名相同，而且没有返回值；
    • 构造函数通常被声明为公有函数；
    • 只要类中有了构造函数，编译器就会 在建立新对象的地方 自动插入 对构造函数调用的代码。因此我们通常说构造函数 在对象被创建的时候 将被自动调用。

            如果类中没有写构造函数，编译器会自动生成一个隐含的默认构造函数，该构造函数的参数列表和函数体皆为空。

    重载的构造函数

    1. class Clock {
    2. public:
    3.     Clock(int newH,int newM, int newS);//构造函数
    4.     Clock()                            //构造函数
    5.     {                           
    6.         hour=0;
    7.         minute=0;
    8.         second=0;
    9.     void setTime(int newH, int newM, int newS);
    10.     void showTime();
    11. private:
    12.     int hour, minute, second;
    13. }；
    14. //其他函数实现略
    15. int main(）
    16. {
    17.     Clock c1(0,0,0);  //调用有参数的构造函数
    18.     Clock c2;         //调用无参数的构造函数
    19.     ...
    20. }

     这里的构造函数有两种重载形式：有参数的和无参数的（即默认构造函数）。

    复制构造/拷贝构造

            复制构造函数是一种特殊的构造函数，具有一般构造函数的所有特性，其形参是本类
    的对象的引用(&)    。其作用是使用一个已经存在的对象（由复制构造函数的参数指定），去初
    始化    同类的一个新对象    。

    复制构造函数的调用： 

    析构函数

            析构函数与构造函数的作用几乎正好相反，它用来完成对象被删除前的一些清理工作，也就是专门做扫尾工作的。析构函数是在对象的生存期即将结束的时刻被自动调用的。它的调用完成之后，对象也就消失了，相应的内存空间也被释放。

    特性 

    • 析构函数的名称是由类名前面加“～"构成，没有返回值；
    • 析构函数不接收任何参数，但可以是虚函数；
    • 构造次数 == 析构次数；
    • 构造次数 > 析构次数 说明内存泄露。
    • 析构函数是构造函数的逆顺序。

    四、类的组合

            类的组合描述的就是 一个类 内嵌其他类的对象 作为成员的情况，它们之间的关系是一种包含与被包含的关系。

            当创建类的对象时，如果这个类具有内嵌对象成员，那么各个内嵌对象将首先被自动
    创建    。因为部件对象是复杂对象的一部分，因此，在创建对象时既要对本类的基本类型数
    据成员进行初始化，又要对内嵌对象成员进行初始化。（创建：先内嵌，后本类）

     例子：

    1. #include 
    2.  
    3. using namespace std;
    4. class Point    //point 类定义
    5. {
    6. public:
    7.     Point(int x = 0,int y = 0);  //构造函数
    8.     Point(const Point &other);   
    9.     void setX(int x);
    10.     void setY(int y);
    11.     int getX()
    12.     {
    13.         return m_x;
    14.     }
    15.     int getY()
    16.     {
    17.         return m_y;
    18.     }
    19.     void show();
    20.     ~Point()
    21.     {
    22.         cout << "~Point"<< endl;
    23.     }
    24. private:
    25.     int m_x,m_y;
    26. };
    27.  
    28. void Point ::show()
    29. {
    30.     cout << "(" << m_x << "," << m_y << ")" << endl;
    31. }
    32. Point ::Point(int x, int y):m_x(x),m_y(y)
    33. {
    34.     cout <<" p(int,int) "<
    35. }
    36. //复制构造函数的实现
    37. Point ::Point(const Point &other):m_x(other.m_x),m_y(other.m_y)
    38. {
    39.     cout << "point &other " << endl;
    40. }
    41.  
    42. //类的组合
    43. class Line //line类的定义
    44. {
    45. public:    //外部接口
    46.     Line(int x1,int y1,int x2,int y2):m_p1(x1,y1),m_p2(x2,y2)
    47.     {
    48.         cout << "line(int,int,int,int)" <
    49.     }
    50.     Line(const Point &p1,const Point &p2):m_p1(p1),m_p2(p2)
    51.     {
    52.         cout<<"point &p"<
    53.     }
    54.     void show()
    55.     {
    56.         m_p1.show();
    57.         cout<<"->";
    58.         m_p2.show();
    59.         cout<
    60.     }
    61.     ~Line()
    62.     {
    63.         cout<<"~Line"<
    64.     }
    65. private:   
    66.         Point m_p1,m_p2; //point类的对象m_p1,m_p2
    67. };
    68. int main()
    69. {
    70.     Point p1(3,4); 
    71.     Point p2(9,10);  //建立point类对象
    72.     Line l(p1,p2);   //建立line类的对象
    73.     l.show();
    74.     return 0;
    75. }

  • 相关阅读:
    DELL台式机Linux ubuntu 20.04.5 安装
    QML使用C++model（撤销恢复）
    实践篇2：深度学习之----LetNet之tensorflow2的实现
    python线程终止线程
    类似Tower的而故事还没结束
    Swagger-go学习笔记
    【迅搜02】究竟什么是搜索引擎？正式介绍XunSearch
    高速，低延，任意频丨庚顿新一代实时数据库鼎力支撑电力装备服务数字化
    【威纶通触摸屏 按键保护（元件安全设置）】
    iMazing传输 iPhone 备忘录和通话记录功能
  • 原文地址：https://blog.csdn.net/weixin_71751116/article/details/141002256