• 2023/9/13 -- C++/QT

    作业：

    1> 将之前定义的栈类和队列类都实现成模板类

    栈：

    1. #include 
    2. #define MAX 40
    3. using namespace std;
    4.  
    5. template <typename T>
    6. class Stack{
    7. private:
    8.     T *data;
    9.     int top;
    10. public:
    11.     Stack();
    12.     ~Stack();
    13.     Stack(const Stack &other);
    14.     Stack &operator=(const Stack &other);
    15.     //判空
    16.     bool empty();
    17.     //判满
    18.     bool full();
    19.     //获取栈的大小
    20.     int size();
    21.     //入栈
    22.     void push();
    23.     //出栈
    24.     void pop();
    25.     //获取栈顶元素
    26.     T get_top();
    27. };
    28.  
    29. template <typename T>
    30. Stack::Stack():data(new T[MAX]),top(-1){
    31.     cout<<"无参构造"<
    32. }
    33. template <typename T>
    34. Stack::~Stack(){
    35.     delete []data;
    36.     cout<<"析构函数"<
    37. }
    38. template <typename T>
    39. Stack::Stack(const Stack &other){
    40.     top = other.top;
    41.     data = new T[MAX];
    42.     memcpy(data,other.data,sizeof(other.data[0])*(other.top+1));
    43.     cout<<"拷贝构造"<
    44. }
    45. template <typename T>
    46. Stack&Stack::operator=(const Stack &other){
    47.     top = other.top;
    48.     memcpy(data,other.data,sizeof(other.data[0])*(other.top+1));
    49.     cout<<"拷贝赋值"<
    50. }
    51. //判空
    52. template <typename T>
    53. bool Stack::empty(){
    54.     return top == -1;
    55. }
    56. //判满
    57. template <typename T>
    58. bool Stack::full(){
    59.     return top == MAX-1;
    60. }
    61. //获取栈的大小
    62. template <typename T>
    63. int Stack::size(){
    64.     return top+1;
    65. }
    66. //入栈
    67. template <typename T>
    68. void Stack::push(){
    69.     if(full()){
    70.         cout<<"栈满!入栈失败!"<
    71.         return;
    72.     }
    73.     T value;
    74.     cout<<"请输入入栈的元素：";
    75.     cin>>value;
    76.     top++;
    77.     data[top] = value;
    78.     cout<" 入栈成功"<
    79. }
    80. //出栈
    81. template <typename T>
    82. void Stack::pop(){
    83.     if(empty()){
    84.         cout<<"栈空!出栈失败!"<
    85.         return;
    86.     }
    87.     T temp = data[top--];
    88.     cout<" 出栈成功"<
    89. }
    90. //获取栈顶元素
    91. template <typename T>
    92. T Stack::get_top(){
    93.     return data[top];
    94. }
    95.  
    96. int main()
    97. {
    98.     Stack<int> s;
    99.     s.push();
    100.     s.push();
    101.     s.push();
    102.     cout<<"s.size = "<size()<
    103.     s.pop();
    104.     cout<<"s.get_top = "<get_top()<
    105.     s.pop();
    106.     s.pop();
    107.     s.pop();
    108.     return 0;
    109. }

    队列：

    1. #include 
    2. #define MAX 40
    3. using namespace std;
    4.  
    5. template<typename T>
    6. class Queue{
    7. private:
    8.     T *data;
    9.     int front;
    10.     int back;
    11. public:
    12.     Queue();
    13.     ~Queue();
    14.     Queue(const Queue &other);
    15.     Queue &operator=(const Queue &other);
    16.     //判空
    17.     bool empty();
    18.     //判满
    19.     bool full();
    20.     //获取队列大小
    21.     int size();
    22.     //入队
    23.     void push();
    24.     //出队
    25.     void pop();
    26. };
    27. template <typename T>
    28. Queue::Queue():data(new T[MAX]),front(0),back(0){
    29.     cout<<"无参构造"<
    30. }
    31. template <typename T>
    32. Queue::~Queue(){
    33.     delete []data;
    34.     cout<<"析构函数"<
    35. }
    36. template <typename T>
    37. Queue::Queue(const Queue &other){
    38.     front = other.front;
    39.     back = other.back;
    40.     data = new T[MAX];
    41.     memcpy(data,other.data,sizeof(other.data[0])*((other.back+MAX-other.front)%MAX));
    42.     cout<<"拷贝构造"<
    43. }
    44. template <typename T>
    45. Queue&Queue::operator=(const Queue &other){
    46.     front = other.front;
    47.     back = other.back;
    48.     memcpy(data,other.data,sizeof(other.data[0])*((other.back+MAX-other.front)%MAX));
    49.     cout<<"拷贝赋值"<
    50. }
    51. //判空
    52. template <typename T>
    53. bool Queue::empty(){
    54.     return front == back;
    55. }
    56. //判满
    57. template <typename T>
    58. bool Queue::full(){
    59.     return (back+1)%MAX == front;
    60. }
    61. //获取队列大小
    62. template <typename T>
    63. int Queue::size(){
    64.     return (back+MAX-front)%MAX;
    65. }
    66. //入队
    67. template <typename T>
    68. void Queue::push(){
    69.     if(full()){
    70.         cout<<"队满!入队失败!"<
    71.         return;
    72.     }
    73.     T value;
    74.     cout<<"请输入要入队的元素：";
    75.     cin>>value;
    76.     data[back] = value;
    77.     back = (back+1)%MAX;
    78.     cout<" 入队成功"<
    79. }
    80. //出队
    81. template <typename T>
    82. void Queue::pop(){
    83.     if(empty()){
    84.         cout<<"队空!出队失败!"<
    85.         return;
    86.     }
    87.     T temp = data[front];
    88.     front = (front+1)%MAX;
    89.     cout<" 出队成功"<
    90. }
    91.  
    92. int main()
    93. {
    94.     Queue<int> q;
    95.     q.push();
    96.     q.push();
    97.     q.push();
    98.     cout<<"q.size = "<size()<
    99.     q.pop();
    100.     q.pop();
    101.     q.pop();
    102.     q.pop();
    103.     cout<<"q.size = "<size()<
    104.     return 0;
    105. }

     

    2> 将继承和多态的课堂代码敲一遍

    一、继承过程中的特殊成员函数

    1.1 构造函数

    1> 父子类中的构造函数不是同一个构造函数，父子类中拥有各自的构造函数

    2> 需要在子类的构造函数初始化列表中，显性调用父类的有参构造完成对子类从父类中继承下来成员的初始化，否则系统会自动调用父类的无参构造来完成对其初始化，此时，如果父类中没有无参构造，则子类的构造函数会报错

    3> 构造顺序：先构造父类再构造子类

    1.2 析构函数

    1> 父子类中会拥有各自的析构函数

    2> 无需在子类的析构函数中显性调用父类的析构函数，当子类对象消亡时，系统会自动调用父类的析构函数，完成对子类从父类继承下来成员的内存回收工作，

    3> 析构顺序：先析构子类再析构父类

    1.3 拷贝构造

    1> 父子类中拥有各自的拷贝构造函数

    2> 需要在子类的拷贝构造函数初始化列表中，显性调用父类的拷贝构造函数完成对子类从父类中继承下来成员的初始化，如果没有显性调用父类的拷贝构造函数，系统会自动调用父类的无参构造来完成对其进行初始化工作，如果父类中没有无参构造，则子类的拷贝构造会报错

    3> 如果父类中有指针成员指向堆区空间，则父类的拷贝构造需要使用深拷贝，如果子类有指针成员指向堆区空间，则子类需要使用深拷贝

    1.4 拷贝赋值

    1> 父子类中拥有给中的拷贝赋值函数

    2> 需要在子类的拷贝赋值函数体内，显性调用父类的拷贝赋值函数，来完成对子类从父类中继承下来成员的赋值，如果没有显性调用父类的拷贝赋值函数，则系统啥也不干，子类从父类继承下来的成员的值保持不变。

    3> 拷贝赋值也涉及深浅拷贝问题

    二、多重继承

    2.1 含义

    所谓多重继承，就是可以由多个类共同派生出一个子类，该子类会继承所有父类的特征

    2.2 继承格式

    1. class  子类名:继承方式1 父类1，继承方式2 父类2，。。。，继承方式n 父类n
    2. {
    3.     //子类拓展成员
    4. }

    三、虚继承

    3.1 菱形继承（钻石继承）问题

    1.                                              A               -->    公共基类
    2.                                            /   \
    3.                                           B     C            -->    中间子类
    4.                                            \   /
    5.                                              D               -->    汇聚子类

    在继承过程中，由一个公共基类，派生出多个中间子类，再由这若干个子类的一部分共同派生出一个汇聚子类，就会导致汇聚子类中保留多份由公共基类传下来的成员，使得子类内存冗余、并且访问起来也比较麻烦

    3.2 虚继承

    1> 为了解决以上的菱形继承问题，我们可以引入虚继承：就是在生成中间子类时，在继承方式前加关键字virtual，那么，再由这些中间子类生成汇聚子类时，汇聚子类中就只保留一份公共基类传下来的数据

    2> 一般的继承，需要在子类的构造函数初始化列表中，显性调用直接父类的构造函数，完成对继承下来成员的初始化。但是，在虚继承中，由于汇聚子类中只有一份公共基类的成员，不能确定由哪个直接父类对公共基类继承下来成员进行初始化，索性不使用直接父类对其进行初始化工作，直接调用公共基类的构造函数来完成对从公共基类中继承下来成员的初始化工作，如果没有显性调用公共基类的有参构造，那么系统会自动调用公共基类的无参构造完成初始化工作，此时，如果公共基类中没有无参构造，则汇聚子类的构造函数会报错。

    1. #include 
    2.  
    3.  
    4. using namespace std;
    5.  
    6.  
    7. class A
    8. {
    9. protected:
    10.     int value_a;
    11. public:
    12.     A() {cout<<"A::无参构造"<
    13.     A(int a):value_a(a) {cout<<"A::有参构造"<
    14. };
    15.  
    16.  
    17. //虚继承格式：再生成中间子类时，继承方式前加virtual关键字
    18. class B:virtual public A
    19. {
    20. protected:
    21.     int value_b;
    22. public:
    23.     B() {cout<<"B::无参构造"<
    24.     B(int a, int b):A(a), value_b(b){cout<<"B::有参构造"<
    25. };
    26.  
    27.  
    28. class C:virtual public A
    29. {
    30. protected:
    31.     int value_c;
    32. public:
    33.     C() {cout<<"C::无参构造"<
    34.     C(int a, int c):A(a), value_c(c){cout<<"C::有参构造"<
    35. };
    36.  
    37.  
    38. //由中间子类生成汇聚子类
    39. class D:public B, public C
    40. {
    41. private:
    42.     int value_d;
    43. public:
    44.     D() {}
    45.     D(int a1, int a2, int b, int c, int d):A(a2),B(a1,b), C(a2,c), value_d(d) {cout<<"D::有参构造"<
    46.  
    47.  
    48.     void show()
    49.     {
    50.         cout<<"value_b = "<
    51.         cout<<"value_c = "<
    52.         cout<<"value_d = "<
    53. //        cout<<"value_a = "<
    54. //        cout<<"value_a = "<
    55.         cout<<"value_a = "<
    56.     }
    57. };
    58.

    四、多态

    4.1 概念

    所谓多态，就是一种形式的多种状态，多态是实现泛型编程的重要部分，能够实现“一条语句多用”

    泛型编程：试图以不变的程序执行可变的功能

    4.2 多态实现条件

    1> 继承：没有继承就没有多态

    2> 虚函数：实现函数重写，保证父子类中使用同一个函数

    3> 父类指针或引用指向子类对象，调用子类中重写的父类的虚函数

    4.3 虚函数

    1> C++中可以将成员函数定义成虚函数，定义格式：在定义成员函数前加关键字virtual

    2> 作用：以保证父类空间能够寻找到子类中重写的跟父类函数原型相同的函数

    4.4 虚函数的底层实现

    4.5 虚析构函数

    1> 引入目的：正确引导delete关键字，在释放父类指针空间时，将子类空间一并释放

    2> 定义格式：在析构函数前面加关键字virtual

    3> 如果类中某个函数设置成虚函数，那么该类的子子孙孙类中的该函数都是虚函数

    4> 在特殊的成员函数中，只有析构函数能设置成虚函数

    5> 在定义类的时候，要养成将析构函数定义成虚析构函数，以便于内存的管理工作

    1. #include 
    2.  
    3.  
    4. using namespace std;
    5.  
    6.  
    7. class Father
    8. {
    9. protected:
    10.     string name;
    11.     int age;
    12.  
    13.  
    14. public:
    15.     Father() {}
    16.     Father(string n, int a):name(n), age(a) {cout<<"Father::有参构造"<
    17.     virtual ~Father() {cout<<"Father::析构函数"<
    18. };
    19.  
    20.  
    21.  
    22.  
    23.  
    24.  
    25. class Son:public Father
    26. {
    27. private:
    28.     string toy;
    29.  
    30.  
    31. public:
    32.     Son(){}
    33.     Son(string n, int a, string t):Father(n,a), toy(t) {cout<<"Son::有参构造"<
    34.     ~Son(){cout<<"Son::析构函数"<
    35. };
    36.  
    37.  
    38.  
    39.  
    40. int main()
    41. {
    42.     //定义父类指针，指向堆区的子类对象
    43.     Father *p = new Son("张三", 18, "car");
    44.  
    45.  
    46.     //释放堆区空间
    47.     delete p;
    48.  
    49.  
    50.     return 0;
    51. }

    4.6 纯虚函数

    1> 引入背景：对于一个类而言，某些函数没有实现的必要，或者实现这些函数没有意义。定义这些函数，纯粹为了让子类对其进行重写，以便于后期可以使用父类的指针或引用指向子类对象，去调用子类中重写的该函数，此时就可以将该函数定义成纯虚函数

    2> 纯虚函数的定义格式：将虚函数的函数体去掉，用=0进行替换：virtual 函数类型 函数名（形参列表） = 0;

    3> 包含纯虚函数的类称为抽象类，抽象类不能实例化对象

    4> 纯虚函数必须由子类进行重写，如果子类中没有重写纯虚函数，那么在子类中该函数还依然是纯虚函数，子类也是抽象类

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. class Shape
    6. {
    7. protected:
    8.     double perimeter;
    9.     double area;
    10.  
    11.  
    12. public:
    13.     Shape():perimeter(0), area(0) {}
    14.  
    15.  
    16.     //定义两个虚函数
    17.     virtual double get_p() = 0;         //该函数就是纯虚函数
    18.  
    19.  
    20.     virtual double get_a() = 0;
    21.  
    22.  
    23. };
    24.  
    25.  
    26. //定义圆形类
    27. class Circle:public Shape
    28. {
    29. private:
    30.     double radius;
    31. public:
    32.     Circle(double r = 0):radius(r){}
    33.  
    34.  
    35.     //重写父类中提供的虚函数
    36.     double get_a() override
    37.     {
    38.         area = 3.14*radius*radius;
    39.         return area;
    40.     }
    41.  
    42.  
    43.     double get_p() override
    44.     {
    45.  
    46.  
    47.         perimeter = 2*radius*3.14;
    48.         return perimeter;
    49.     }
    50. };
    51.  
    52.  
    53.  
    54.  
    55. //定义矩形类
    56. class Rectangle:public Shape
    57. {
    58. private:
    59.     double width;
    60.     double height;
    61. public:
    62.     Rectangle(double w=0, double h=0):width(w), height(h){}
    63.  
    64.  
    65.     //重写父类中提供的虚函数
    66.     double get_a() override
    67.     {
    68.         area = width*height;
    69.         return area;
    70.     }
    71.  
    72.  
    73.     double get_p() override
    74.     {
    75.         perimeter = 2*(width+height);
    76.         return perimeter;
    77.     }
    78. };
    79.  
    80.  
    81. //定义全局函数输出给定图形的周长和面积
    82. void show(Shape &s)
    83. {
    84.     cout<<"周长 = "<get_p()<<"   面积 = "<get_a()<
    85.     //cout<<"周长 = "<
      }
    86.  
    87.  
    88. int main()
    89. {
    90.     //实例化一个圆形
    91.     Circle c1(2);
    92.     show(c1);
    93.  
    94.  
    95.     Rectangle r1(3,4);
    96.     show(r1);
    97.     cout<<"*******************************"<
    98.     
    99.     //Shape s;                 //包含纯虚函数的类称为抽象类，抽象类不能实例化对象
    100.  
    101.  
    102.     return 0;
    103. }

    五、泛型编程之模板（template）

    模板是能够将数据类型进一步抽象，我们之前所接触的抽象，都是完成对数据的相关抽象

    模板分为模板函数、模板类

    5.1 模板函数

    1> 程序员有时定义函数时，会因为函数参数类型不同，导致同一功能的函数需要定义多个，即使有函数重载，系统会自动匹配相应的函数，也会造成代码的冗余

    2> C++提供函数模板机制：使用函数时，形参的类型也由实参进行传递，定义模板函数时，模板函数的参数，不仅能接收实参的值，也能接收实参的类型

    3> 定义格式

    1. template <typename 类型形参1，typename 类型形参2，。。。，typename 类型形参n>
    2. 函数返回值类型  函数名（形参列表）{函数体内容}
    3.  
    4. 注意
    5. template是定义模板的关键字
    6. <>:中是类型的参数，用于接收实参传递的类型
    7. typename:用于定义类型形参变量的，也可以使用class
    8. 函数体中，可以使用模板中的类型作为函数返回值、函数形参、局部变量的类型

    4> 调用方式

    1、隐式调用：调用时跟普通函数调用一样，系统会自动根据传进来的实参类型，推导出模板的类型参数

    2、显式调用：在函数名后，实参括号前，加<>，传递类型形参的值，调用原则：尖找尖、圆找圆

    3、一般模板函数要求显式调用

    5> 注意事项

    一个模板下面只能定义一个函数，如果要定义多个模板函数，需要定义多个模板

    1. #include 
    2.  
    3.  
    4. using namespace std;
    5.  
    6.  
    7. //定义一个模板函数
    8. template<typename T>
    9. T sum(T m, T n)
    10. {
    11.     return m+n;
    12. }
    13.  
    14.  
    15. //定义新的模板函数，不能多个模板函数共同使用一个模板
    16. template<typename T>
    17. T div(T m, T n)
    18. {
    19.     return m-n;
    20. }
    21.  
    22.  
    23.  
    24.  
    25.  
    26.  
    27. int main()
    28. {
    29.     cout << sum<int>(3.3,5) << endl;           //8  显式调用模板函数
    30.     cout << sum(3.2,5.3) << endl;        //8.5
    31.     cout << sum(string("hello"),string("world")) << endl;
    32.  
    33.  
    34.     return 0;
    35. }
    36.

    6> 模板函数的特化

    当基础模板和特化模板同时出现时，如果是隐式调用，默认调用基础模板，如果是显式调用，则会调用特化模板

    5.2 模板类

    1> 引入背景：程序员有时定义类时，可能由于数据类型的不同，导致同样功能的类，需要定义多个，造成代码冗余问题

    2> C++引入模板类，类中的一些类型可以是由调用时给定，由实参进行传递

    3> 定义格式

    1. template <typename 类型形参1，typename 类型形参2，。。。，typename 类型形参n>
    2. class 类名
    3. {
    4.     //成员可以使用模板中的类型
    5. };

    4> 调用方式:只能显式调用，不能隐式调用

    5> 在定义模板时，模板类外，但凡使用到类名，都需要重新再定义模板，并且使用类名时，需要给定类型

    1. #include 
    2.  
    3.  
    4. using namespace std;
    5.  
    6.  
    7. template<typename T>
    8. class Node
    9. {
    10. private:
    11.     T data;              //数据域
    12.     Node *next;           //指针域
    13.  
    14.  
    15. public:
    16.     Node():next(NULL) {}           //无参构造
    17.     Node(T d):data(d), next(NULL){}    //有参构造
    18.  
    19.  
    20.     void show();
    21.  
    22.  
    23. };
    24.  
    25.  
    26. //在模板类外，但凡使用到模板类，都必须显性调用给定类型，需要重新定义模板
    27. template <typename T>
    28. void Node::show()
    29. {
    30.     cout<<"data = "<
    31. }
    32.  
    33.  
    34.  
    35.  
    36.  
    37.  
    38.  
    39.  
    40. int main()
    41. {
    42.     Node<int> n1(520);        //模板类的使用必须显性调用
    43.     n1.show();
    44.  
    45.  
    46.     Node<double> n2(3.14);
    47.     n2.show();
    48.     
    49.  
    50.  
    51.     return 0;
    52. }

  • 相关阅读:
    html5期末大作业 基于HTML+CSS制作dr钻戒官网5个页面 企业网站制作
    Kubernetes安装nginx-controller作为统一网关
    暑假算法训练day1
    《InnoDB引擎七》InnoDB关键特性-插入缓存
    Hibiki Run 市场火爆，“Listen to Earn”赛道的现象级应用？
    Python清理数据的常用方法总结
    在Linux中执行shell(bash)脚本的方法 2208笔记
    图像对比度增强易语言代码
    Nginx Web服务器搭建
    SpringMVC异常处理器
  • 原文地址：https://blog.csdn.net/weixin_54147737/article/details/132863768