• 数据结构实战开发教程（二）泛型编程简介、智能指针示例、异常类构建、顶层父类的创建

    八、泛型编程简介

    1、数据结构课程的特点

    • 专注于数据元素之间的关系
    • 专注于特定结构之上的算法
    • 数据结构课程并不关注数据元素的具体类型！

    2、问题

    如何为数据结构的学习选择合适的语言？

    3、经验分享

    支持泛型编程的语言最适合数据结构课程的学习？

    4、泛型编程的概念

    • 不考虑具体数据类型的编程方式

            

    5、C++中的函数模板

    • 一种特殊的函数可用不同类型进行调用
    • 看起来和普通函数很相似，区别是类型可被参数化

            

    6、函数模板的语法规则

    • template关键字用于声明开始进行泛型编程
    • typename关键字用于声明泛指类型

            

    7、函数模板的使用

    • 自动类型推导调用
    • 具体类型显示调用

            

    8、编程实验：函数模板初探

    与下一个实验在一起。

    9、C++中的类模板

    • 以相同的方式处理不同的类型
    • 在类声明前使用template进行标识
    • < typename T>用于说明类中使用的泛指类型 T

            

    10、类模板的应用

    • 只能显示指定具体类型，无法自动推导
    • 使用具体类型<Type>定义对象

            

    11、编程实验：类模板初探

    1. #include <iostream>
    2.  
    3. using namespace std;
    4.  
    5. template <typename T>
    6. void Swap(T& a, T& b)
    7. {
    8.     T t = a;
    9.     a = b;
    10.     b = t;
    11. }
    12.  
    13. template <typename T>
    14. class Op
    15. {
    16. public:
    17.     T process(T v)
    18.     {
    19.         return v * v;
    20.     }
    21. };
    22.  
    23. int main()
    24. {
    25.     int a = 2;
    26.     int b = 1;
    27.  
    28.     Swap(a, b);
    29.  
    30.     cout << "a = " << a << " " << "b = " << b << endl;
    31.  
    32.     double c = 0.01;
    33.     double d = 0.02;
    34.  
    35.     Swap<double>(d, c);
    36.  
    37.     cout << "c = " << c << " " << "d = " << d << endl;
    38.  
    39.     Op<int> opInt;
    40.     Op<double> opDouble;
    41.  
    42.     cout << "5 * 5 = " << opInt.process(5) << endl;
    43.     cout << "0.3 * 0.3 = " << opDouble.process(0.3) << endl;
    44.  
    45.     return 0;
    46. }

    12、小结

    • 模板是泛型编程理论在C++中的实现
    • 函数模板支持参数的自动推导和显示指定
    • 类模板在使用时只能显示指定类型
    • 类模板非常适用于编写数据结构相关的代码

    九、智能指针示例

    1、内存泄漏（臭名昭著的Bug ）

    • 动态申请堆空间，用完后不归还
    • C++语言中没有垃圾回收的机制（c#、java、Python有）
    • 指针无法控制所指堆空间的生命周期

    2、当代C++软件平台中的智能指针

    • 指针生命周期结束时主动释放堆空间
    • 一片堆空间最多只能由一个指针标识
    • 杜绝指针运算和指针比较

    3、智能指针的设计方案

    • 通过类模板描述指针的行为
      • 能够定义不同类型的指针对象
    • 重载指针特征操作符（->和*）
      • 利用对象模拟原生指针的行为

    4、编程实验：智能指针

    SmartPointer.h

    1. #ifndef SMARTPOINTER_H_
    2. #define SMARTPOINTER_H_
    3. /*******************************************************************************
    4.  *                              Include Files                                  *
    5.  *******************************************************************************/
    6. #include "Pointer.h"
    7. /*******************************************************************************
    8.  *                             Type Definition                                 *
    9.  *******************************************************************************/
    10. namespace DTLib
    11. {
    12.  
    13. template <typename T>                                               // 泛型编程 - 类模板
    14. class SmartPointer : public Pointer<T>                              // 基于普通指针类
    15. {
    16. public:
    17.     SmartPointer(T* p = NULL) : Pointer<T>(p)                       // 构造函数 - 调用父类构造函数 - 默认指针为NULL
    18.     {
    19.  
    20.     }
    21.  
    22.     SmartPointer(const SmartPointer<T>& obj)                        // 拷贝构造函数
    23.     {
    24.         this->m_pointer = obj.m_pointer;                            // 当前对象的堆空间 指向 引入的堆空间
    25.  
    26.         const_cast<SmartPointer<T>&>(obj).m_pointer = NULL;         // 将原来的堆空间指针置NULL  const_cast 去除对象的const属性
    27.     }
    28.  
    29.     SmartPointer<T>& operator= (const SmartPointer<T>& obj)         // 重载赋值操作符
    30.     {
    31.         if( this != &obj )                                          // 判断是否为 自赋值
    32.         {
    33.             T* p = this->m_pointer;                                 //为了防止类异常抛出，所以最后释放堆空间
    34.  
    35.             this->m_pointer = obj.m_pointer;                        // 当前对象的堆空间 指向 引入的堆空间
    36.  
    37.             const_cast<SmartPointer<T>&>(obj).m_pointer = NULL;     // 将原来的堆空间指针置NULL  const_cast 去除对象的const属性
    38.  
    39.             delete p;                                               // 释放当前指针指向的堆空间
    40.         }
    41.  
    42.         return *this;                                               // 返回自己(支持连续赋值)
    43.     }
    44.  
    45.     ~SmartPointer()                                                 // 析构函数 - 释放智能指针对应的堆空间
    46.     {
    47.         delete this->m_pointer;
    48.     }
    49. };
    50.  
    51. }
    52.  
    53. #endif // SMARTPOINTER_H_

    Pointer.h

    1. #ifndef POINTER_H_
    2. #define POINTER_H_
    3. /*******************************************************************************
    4.  *                              Include Files                                  *
    5.  *******************************************************************************/
    6. #include "Object.h"
    7. /*******************************************************************************
    8.  *                             Type Definition                                 *
    9.  *******************************************************************************/
    10. namespace DTLib
    11. {
    12.  
    13. template < typename T >         // 泛型编程 - 类模板 T
    14. class Pointer : public Object
    15. {
    16. protected:                      // protected 可以被子类直接访问; 不能被外界直接访问
    17.     T* m_pointer;
    18. public:
    19.     Pointer(T* p = NULL)        // 构造函数 - 默认指针为NULL
    20.     {
    21.         m_pointer = p;
    22.     }
    23.  
    24.     T* operator-> ()            // 重载 ->  返回指针地址
    25.     {
    26.         return m_pointer;
    27.     }
    28.  
    29.     T& operator* ()             // 重载 *  返回值
    30.     {
    31.         return *m_pointer;
    32.     }
    33.  
    34.     const T* operator-> () const // 重载 ->  返回指针地址            const对象只能调用const的成员函数
    35.     {
    36.         return m_pointer;
    37.     }
    38.  
    39.     const T& operator* () const // 重载 *    返回值                 const对象只能调用const的成员函数
    40.     {
    41.         return *m_pointer;
    42.     }
    43.  
    44.     bool isNull() const         // 判断当前的智能指针是否为空指针     const对象只能调用const的成员函数
    45.     {
    46.         return (m_pointer == NULL);
    47.     }
    48.  
    49.     T* get() const              // 获取智能指针的值                  const对象只能调用const的成员函数
    50.     {
    51.         return m_pointer;
    52.     }
    53.  
    54.     virtual ~Pointer() = 0;     // 析构函数  纯虚函数(抽象类)
    55. };
    56.  
    57. template < typename T >
    58. Pointer<T>::~Pointer()
    59. {
    60.  
    61. }
    62.  
    63. }
    64.  
    65. #endif // POINTER_H_

    5、智能指针分析

    智能指针的使用军规：只能用来指向堆空间中的单个对象或者变量

    6、小结

    • 指针特征操作符( ->和*)可以被重载
    • 重载指针特征符能够使用对象代替指针
    • 智能指针只能用于指向堆空间中的内存
    • 智能指针的意义在于最大程度的避免内存问题

    十、C++异常简介

    1、C++内置了异常处理的语法元素try ... catch …

    • try语句处理正常代码逻辑
    • catch语句处理异常情况
    • try语句中的异常由对应的catch语句处理

            

    2、C++通过throw语句抛出异常信息

            

    3、C++异常处理分析

    • throw抛出的异常必须被catch处理
      • 当前函数能够处理异常，程序继续往下执行
      • 当前函数无法处理异常，则函数停止执行，并返回
    • 未被处理的异常会顺着函数调用栈向上传播，直到被处理为止，否则程序将停止执行。

            

    4、编程实验：C++异常处理初探

    5、C++异常简介

    • 同一个try语句可以跟上多个catch语句
      • catch语句可以定义具体处理的异常类型
      • 不同类型的异常由不同的catch语句负责处理
      • try语句中可以抛出任何类型的异常
      • catch(.….)用于处理所有类型的异常
      • 任何异常都只能被捕获( catch )一次

    6、异常处理的匹配规则

            

    7、编程实验：异常类型匹配

    1. #include <iostream>
    2.  
    3. using namespace std;
    4.  
    5. double divide(double a, double b)
    6. {
    7.     const double delta = 0.000000000000001;
    8.     double ret = 0;
    9.  
    10.     if( !((-delta < b) && (b < delta)) ) {
    11.         ret = a / b;
    12.     }
    13.     else {
    14.         throw 0;   // 产生除 0 异常
    15.     }
    16.  
    17.     return ret;
    18. }
    19.  
    20. void Demo1()
    21. {
    22.     try
    23.     {
    24.         throw 'c';
    25.     }
    26.     catch(int i)
    27.     {
    28.         cout << "catch(int i)" << endl;
    29.     }
    30.     catch(double d)
    31.     {
    32.         cout << "catch(double d)" << endl;
    33.     }
    34.     catch(char c)
    35.     {
    36.         cout << "catch(char c)" << endl;
    37.     }
    38. }
    39.  
    40. void Demo2()
    41. {
    42.     throw 0.0001; // "D.T.Software";   // const char*
    43. }
    44.  
    45. int main()
    46. {
    47.     cout << "main() begin" << endl;
    48.  
    49.     try
    50.     {
    51.         double c = divide(1, 1);
    52.  
    53.         cout << "c = " << c << endl;
    54.     }
    55.     catch(...)
    56.     {
    57.         cout << "Divided by zero..."  << endl;
    58.     }
    59.  
    60.     Demo1();
    61.  
    62.     try
    63.     {
    64.         Demo2();
    65.     }
    66.     catch(char* c)
    67.     {
    68.         cout << "catch(char* c)" << endl;
    69.     }
    70.     catch(const char* cc)
    71.     {
    72.         cout << "catch(char* cc)" << endl;
    73.     }
    74.     catch(...)
    75.     {
    76.         cout << "catch(...)" << endl;
    77.     }
    78.  
    79.     cout << "main() end" << endl;
    80.  
    81.     return 0;
    82. }

    8、小结

    • C++中直接支持异常处理的概念
    • try... catch...是C++中异常处理的专用语句
    • try语句处理正常代码逻辑，catch语句处理异常情况
    • 同一个try语句可以跟上多个catch语句
    • 异常处理必须严格匹配，不进行任何的类型转换

     

    十一、异常类构建

    1、异常类构建

    • 异常的类型可以是自定义类类型
    • 对于类类型异常的匹配依旧是至上而下严格匹配
    • 赋值兼容性原则在异常匹配中依然适用
    • 一般而言
      • 匹配子类异常的catch放在上部
      • 匹配父类异常的catch放在下部

    2、现代C++库必然包含充要的异常类族

    • 异常类是数据结构类所依赖的“基础设施”！

            

    3、异常类功能定义

            

    4、异常类中的接口定义

    5、编程实验：创建异常类族

    Exception.cpp

    1. /*******************************************************************************
    2.  *                              Include _Files                                  *
    3.  *******************************************************************************/
    4. #include "Exception.h"
    5. #include <cstring>
    6. #include <cstdlib>
    7. #include <cstdio>
    8.  
    9. using namespace std;
    10. /*******************************************************************************
    11.  *                             Type Definition                                 *
    12.  *******************************************************************************/
    13. namespace DTLib
    14. {
    15. /**********************************************************************
    16. * Function:        Exception::init()
    17. * Description:     辅助初始化函数
    18. * Table Accessed: 
    19. * Table Updated:  
    20. * Input:            _message            异常的说明信息
    21. *                   _file               发生异常的文件名
    22. *                   _line               发生异常的行号
    23. * Output:           m_message           异常的说明信息      (类中成员)
    24. *                   m_location          异常的文件名和行号  (类中成员)
    25. * Return:          
    26. * Others:           用于被重载函数调用
    27. * Modify   Date     Version    Author      Modification
    28. * ------------------------------------------------------------
    29. *       2022/03/09    1.0                            Create        
    30. **********************************************************************/
    31. void Exception::init(const char* _message, const char* _file, int _line)
    32. {
    33.     #define STR_CAT_LINE        16      // 行号字符串拼接长度
    34.     #define STR_CAT_SYMBOL      2       // 文件名和行号的隔离符号(:); 字符串结束符\0
    35.  
    36.     // 获取 异常的说明信息
    37.     m_message = (_message ? strdup(_message) : NULL);   //判断_message是否为空(strdup默认入参不为空)  strdup将字符串复制到堆空间，返回指针地址
    38.  
    39.     // 获取 发生异常的文件名和行号
    40.     if( _file != NULL )
    41.     {
    42.         // 将行号转为字符串类型
    43.         char acLineStrcat[STR_CAT_LINE] = {0}; 
    44.         // itoa(_line, acLineStrcat, 10);
    45.         snprintf(acLineStrcat, sizeof(acLineStrcat), "%d", _line);
    46.  
    47.         // 申请堆空间，进行拼接文件名和行号
    48.         m_location = static_cast<char*>(malloc(strlen(_file) + strlen(acLineStrcat) + STR_CAT_SYMBOL));
    49.         if( m_location != NULL )
    50.         {
    51.             m_location = strcpy(m_location, _file);                 // 拷贝文件名
    52.             m_location = strcat(m_location, ":");                   // 拼接  ：
    53.             m_location = strcat(m_location, acLineStrcat);          // 拼接 行号
    54.         }
    55.     }
    56.     else
    57.     {
    58.         m_location = NULL;
    59.     }
    60. }
    61.  
    62. /**********************************************************************
    63. * Function:        Exception::Exception()
    64. * Description:      重载函数
    65. * Input:            _message            异常的说明信息
    66. *                   _file               发生异常的文件名
    67. *                   _line               发生异常的行号
    68. * Others:           用于被重载函数调用
    69. * Modify   Date     Version    Author      Modification
    70. * ------------------------------------------------------------
    71. *       2022/03/09    1.0                            Create        
    72. **********************************************************************/
    73. Exception::Exception(const char* _message)
    74. {
    75.     init(_message, NULL, 0);
    76. }
    77.  
    78. Exception::Exception(const char* _file, int _line)
    79. {
    80.     init(NULL, _file, _line);
    81. }
    82.  
    83. Exception::Exception(const char* _message, const char* _file, int _line)
    84. {
    85.     init(_message, _file, _line);
    86. }
    87.  
    88. /**********************************************************************
    89. * Function:        Exception::Exception()
    90. * Description:      拷贝函数重载(深拷贝)
    91. * Input:            Exception           传入待拷贝的Exception类
    92. * Output:           Exception           创建的Exception类   (类中成员)
    93. * Return:  
    94. * Others:           深拷贝 - 成员指向了动态内存空间
    95. * Modify   Date     Version    Author      Modification
    96. * ------------------------------------------------------------
    97. *       2022/03/09    1.0                            Create        
    98. **********************************************************************/
    99. Exception::Exception(const Exception& _eWaitCopy)
    100. {
    101.     m_message = strdup(_eWaitCopy.m_message);
    102.     m_location = strdup(_eWaitCopy.m_location);
    103. }
    104.  
    105. /**********************************************************************
    106. * Function:        Exception::Exception()
    107. * Description:      赋值运算符重载
    108. * Input:            Exception           传入待拷贝的Exception类
    109. * Output:           Exception           创建的Exception类   (类中成员)
    110. * Return:           Exception           当前类的指针
    111. * Others:           返回当前类的指针，代表允许连续赋值
    112. * Modify   Date     Version    Author      Modification
    113. * ------------------------------------------------------------
    114. *       2022/03/09    1.0                            Create        
    115. **********************************************************************/
    116. Exception& Exception::operator= (const Exception& _eWaitCopy)
    117. {
    118.     if( this != &_eWaitCopy )
    119.     {
    120.         free(m_message);
    121.         free(m_location);
    122.  
    123.         m_message = strdup(_eWaitCopy.m_message);
    124.         m_location = strdup(_eWaitCopy.m_location);
    125.     }
    126.  
    127.     return *this;
    128. }
    129.  
    130. /**********************************************************************
    131. * Function:        Exception::message()
    132. * Description:      返回异常的说明信息的指针
    133. * Input:            
    134. * Output:           
    135. * Return:           char* m_message     返回异常的说明信息的指针
    136. * Others:           
    137. * Modify   Date     Version    Author      Modification
    138. * ------------------------------------------------------------
    139. *       2022/03/09    1.0                            Create        
    140. **********************************************************************/
    141. const char* Exception::message() const
    142. {
    143.     return m_message;
    144. }
    145.  
    146. /**********************************************************************
    147. * Function:        Exception::location()
    148. * Description:      返回异常文件名和行号的指针
    149. * Input:            
    150. * Output:           
    151. * Return:           char* m_location    返回异常文件名和行号的指针
    152. * Others:           
    153. * Modify   Date     Version    Author      Modification
    154. * ------------------------------------------------------------
    155. *       2022/03/09    1.0                            Create        
    156. **********************************************************************/
    157. const char* Exception::location() const
    158. {
    159.     return m_location;
    160. }
    161.  
    162. /**********************************************************************
    163. * Function:        Exception::~Exception()
    164. * Description:      析构函数
    165. * Input:            
    166. * Output:           
    167. * Return:           
    168. * Others:           纯虚函数(抽象类) - 纯虚函数的实现由子类完成，这里是个例外，但凡定义析构函数就必须要提供实现，不管是不是纯虚的.
    169. * Modify   Date     Version    Author      Modification
    170. * ------------------------------------------------------------
    171. *       2022/03/09    1.0                            Create        
    172. **********************************************************************/
    173. Exception::~Exception()
    174. {
    175.     free(m_message);
    176.     free(m_location);
    177. }
    178.  
    179. }

    Exception.h

    1. #ifndef EXCEPTION_H_
    2. #define EXCEPTION_H_
    3. /*******************************************************************************
    4.  *                              Include Files                                  *
    5.  *******************************************************************************/
    6. #include "Object.h"
    7.  
    8. /*******************************************************************************
    9.  *                             Type Definition                                 *
    10.  *******************************************************************************/
    11. namespace DTLib
    12. {
    13. #define THROW_EXCEPTION(e, m) (throw e(m, __FILE__, __LINE__))      // 异常类型；说明信息
    14.  
    15. /****** 异常父类 ******/
    16. class Exception : public Object
    17. {
    18. protected:
    19.     char* m_message;                                                // 当前异常的说明信息
    20.     char* m_location;                                               // 当前异常的位置信息
    21.  
    22.     void init(const char* _message, const char* _file, int _line);     // 辅助初始化 - 定义了多个重载函数
    23. public:
    24.     Exception(const char* message);                                 // 构造函数 - 重载函数
    25.     Exception(const char* file, int line);                          // 构造函数 - 重载函数
    26.     Exception(const char* message, const char* file, int line);     // 构造函数 - 重载函数
    27.  
    28.     Exception(const Exception& _eWaitCopy);                                  // 拷贝构造函数
    29.     Exception& operator= (const Exception& _eWaitCopy);                      // 赋值构造函数
    30.  
    31.     virtual const char* message() const;                            // 异常对象的说明信息
    32.     virtual const char* location() const;                           // 异常对象的位置信息
    33.  
    34.     virtual ~Exception() = 0;                                       // 纯虚函数(抽象类) - 析构函数
    35. };
    36.  
    37. /****** 计算异常子类 ******/
    38. class ArithmeticException : public Exception
    39. {
    40. public:
    41.     // 显式调用父类构造函数
    42.     ArithmeticException() : Exception(0) { }
    43.     ArithmeticException(const char* message) : Exception(message) { }
    44.     ArithmeticException(const char* file, int line) : Exception(file, line) { }
    45.     ArithmeticException(const char* message, const char* file, int line) : Exception(message, file, line) { }
    46.  
    47.     // 显式调用父类拷贝构造函数
    48.     ArithmeticException(const ArithmeticException& eWaitCopy) : Exception(eWaitCopy) { }
    49.     // 调用父类赋值重载函数
    50.     ArithmeticException& operator= (const ArithmeticException& eWaitCopy)
    51.     {
    52.         Exception::operator=(eWaitCopy);
    53.  
    54.         return *this;
    55.     }
    56. };
    57.  
    58. /****** 空指针异常子类 ******/
    59. class NullPointerException : public Exception
    60. {
    61. public:
    62.     // 显式调用父类构造函数
    63.     NullPointerException() : Exception(0) { }
    64.     NullPointerException(const char* message) : Exception(message) { }
    65.     NullPointerException(const char* file, int line) : Exception(file, line) { }
    66.     NullPointerException(const char* message, const char* file, int line) : Exception(message, file, line) { }
    67.  
    68.     // 显式调用父类拷贝构造函数
    69.     NullPointerException(const NullPointerException& eWaitCopy) : Exception(eWaitCopy) { }
    70.     // 调用父类赋值重载函数
    71.     NullPointerException& operator= (const NullPointerException& eWaitCopy)
    72.     {
    73.         Exception::operator=(eWaitCopy);
    74.  
    75.         return *this;
    76.     }
    77. };
    78.  
    79. /****** 越界异常子类 ******/
    80. class IndexOutOfBoundsException : public Exception
    81. {
    82. public:
    83.     // 显式调用父类构造函数
    84.     IndexOutOfBoundsException() : Exception(0) { }
    85.     IndexOutOfBoundsException(const char* message) : Exception(message) { }
    86.     IndexOutOfBoundsException(const char* file, int line) : Exception(file, line) { }
    87.     IndexOutOfBoundsException(const char* message, const char* file, int line) : Exception(message, file, line) { }
    88.  
    89.     // 显式调用父类拷贝构造函数
    90.     IndexOutOfBoundsException(const IndexOutOfBoundsException& eWaitCopy) : Exception(eWaitCopy) { }
    91.     // 调用父类赋值重载函数
    92.     IndexOutOfBoundsException& operator= (const IndexOutOfBoundsException& eWaitCopy)
    93.     {
    94.         Exception::operator=(eWaitCopy);
    95.  
    96.         return *this;
    97.     }
    98. };
    99.  
    100. /****** 内存不足异常子类 ******/
    101. class NoEnoughMemoryException : public Exception
    102. {
    103. public:
    104.     // 显式调用父类构造函数
    105.     NoEnoughMemoryException() : Exception(0) { }
    106.     NoEnoughMemoryException(const char* message) : Exception(message) { }
    107.     NoEnoughMemoryException(const char* file, int line) : Exception(file, line) { }
    108.     NoEnoughMemoryException(const char* message, const char* file, int line) : Exception(message, file, line) { }
    109.  
    110.     // 显式调用父类拷贝构造函数
    111.     NoEnoughMemoryException(const NoEnoughMemoryException& eWaitCopy) : Exception(eWaitCopy) { }
    112.     // 调用父类赋值重载函数
    113.     NoEnoughMemoryException& operator= (const NoEnoughMemoryException& eWaitCopy)
    114.     {
    115.         Exception::operator=(eWaitCopy);
    116.  
    117.         return *this;
    118.     }
    119. };
    120.  
    121. /****** 参数错误异常子类 ******/
    122. class InvalidParameterException : public Exception
    123. {
    124. public:
    125.     // 显式调用父类构造函数
    126.     InvalidParameterException() : Exception(0) { }
    127.     InvalidParameterException(const char* message) : Exception(message) { }
    128.     InvalidParameterException(const char* file, int line) : Exception(file, line) { }
    129.     InvalidParameterException(const char* message, const char* file, int line) : Exception(message, file, line) { }
    130.  
    131.     // 显式调用父类拷贝构造函数
    132.     InvalidParameterException(const InvalidParameterException& eWaitCopy) : Exception(eWaitCopy) { }
    133.     // 调用父类赋值重载函数
    134.     InvalidParameterException& operator= (const InvalidParameterException& eWaitCopy)
    135.     {
    136.         Exception::operator=(eWaitCopy);
    137.  
    138.         return *this;
    139.     }
    140. };
    141.  
    142. /****** 成员函数调用异常子类 ******/
    143. class InvalidOperationException : public Exception
    144. {
    145. public:
    146.     // 显式调用父类构造函数
    147.     InvalidOperationException() : Exception(0) { }
    148.     InvalidOperationException(const char* message) : Exception(message) { }
    149.     InvalidOperationException(const char* file, int line) : Exception(file, line) { }
    150.     InvalidOperationException(const char* message, const char* file, int line) : Exception(message, file, line) { }
    151.  
    152.     // 显式调用父类拷贝构造函数
    153.     InvalidOperationException(const InvalidOperationException& eWaitCopy) : Exception(eWaitCopy) { }
    154.     // 调用父类赋值重载函数
    155.     InvalidOperationException& operator= (const InvalidOperationException& eWaitCopy)
    156.     {
    157.         Exception::operator=(eWaitCopy);
    158.  
    159.         return *this;
    160.     }
    161. };
    162.  
    163. }
    164.  
    165. #endif // EXCEPTION_H_

    6、设计原则

    在可复用代码库设计时，尽量使用面向对象技术进行架构，尽量使用异常处理机制分离正常逻辑和异常逻辑。

    7、小结

    • 现代C++库必然包含充要的异常类族
    • 所有库中的数据结构类都依赖于异常机制
    • 异常机制能够分离库中代码的正常逻辑和异常逻辑

            

    十二、顶层父类的创建

    1、当代软件架构实践中的经验

    • 尽量使用单重继承的方式进行系统设计
    • 尽量保持系统中只存在单一的继承树
    • 尽量使用组合关系代替继承关系

    2、不幸的事实

    • C++语言的灵活性使得代码中可以存在多个继承树
    • C++编译器的差异使得同样的代码可能表现不同的行为

    new操作如果失败会发生什么？

    3、创建DTLib::object类的意义

    • 遵循经典设计准则，所有数据结构都继承自Object类
    • 定义动态内存申请的行为，提高代码的移植性，避免不同编译器的影响

    4、顶层父类的接口定义

            

    5、编程实验：顶层父类的创建

    Object.h

    1. #ifndef OBJECT_H_
    2. #define OBJECT_H_
    3. /*******************************************************************************
    4.  *                              Include _Files                                  *
    5.  *******************************************************************************/
    6. #include <cstdlib>
    7. /*******************************************************************************
    8.  *                             Type Definition                                 *
    9.  *******************************************************************************/
    10. namespace DTLib
    11. {
    12.  
    13. class Object
    14. {
    15. public:
    16.     void* operator new (size_t size) throw();       // 重载 new
    17.     void operator delete (void* p);                 // 重载 delete
    18.     void* operator new[] (size_t size) throw();     // 重载 new[]
    19.     void operator delete[] (void* p);               // 重载 delete[]
    20.     bool operator == (const Object& obj);           // 重载 ==          自定义类可能会出现比较操作符，此处为默认写法 - 判断地址是否相同
    21.     bool operator != (const Object& obj);           // 重载 !=          自定义类可能会出现比较操作符，此处为默认写法 - 判断地址是否相同
    22.     virtual ~Object() = 0;                          // 析构函数(纯虚函数 抽象类)
    23. };
    24.  
    25.  
    26. }
    27.  
    28. #endif // OBJECT_H_

    Object.cpp

    1. /*******************************************************************************
    2.  *                              Include _Files                                  *
    3.  *******************************************************************************/
    4. #include "Object.h"
    5. #include <cstdlib>
    6. /*******************************************************************************
    7.  *                             Type Definition                                 *
    8.  *******************************************************************************/
    9. using namespace std;
    10.  
    11. namespace DTLib
    12. {
    13.  
    14. /**********************************************************************
    15. * Function:        Object::operator new()
    16. * Description:     重载 new
    17. * Table Accessed: 
    18. * Table Updated:  
    19. * Input:            size                字节大小
    20. * Output:           void*               指针地址
    21. * Return:          
    22. * Others:           throw() 这个重载函数不会抛出任何异常
    23. * Modify   Date     Version    Author      Modification
    24. * ------------------------------------------------------------
    25. *       2022/03/09    1.0                            Create        
    26. **********************************************************************/
    27. void* Object::operator new (size_t size) throw()
    28. {
    29.     return malloc(size);
    30. }
    31.  
    32. /**********************************************************************
    33. * Function:        Object::operator delete()
    34. * Description:     重载 delete
    35. * Table Accessed: 
    36. * Table Updated:  
    37. * Input:            void*               指针地址
    38. * Output:           
    39. * Return:          
    40. * Others:           
    41. * Modify   Date     Version    Author      Modification
    42. * ------------------------------------------------------------
    43. *       2022/03/09    1.0                            Create        
    44. **********************************************************************/
    45. void Object::operator delete (void* p)
    46. {
    47.     free(p);
    48. }
    49.  
    50. /**********************************************************************
    51. * Function:        Object::operator new[]()
    52. * Description:     重载 new[](数组)
    53. * Table Accessed: 
    54. * Table Updated:  
    55. * Input:            size                字节大小
    56. * Output:           void*               指针地址
    57. * Return:          
    58. * Others:           throw() 这个重载函数不会抛出任何异常
    59. * Modify   Date     Version    Author      Modification
    60. * ------------------------------------------------------------
    61. *       2022/03/09    1.0                            Create        
    62. **********************************************************************/
    63. void* Object::operator new[] (size_t size) throw()
    64. {
    65.     return malloc(size);
    66. }
    67.  
    68. /**********************************************************************
    69. * Function:        Object::operator delete[]()
    70. * Description:     重载 delete[](数组)
    71. * Table Accessed: 
    72. * Table Updated:  
    73. * Input:            void*               指针地址
    74. * Output:           
    75. * Return:          
    76. * Others:           
    77. * Modify   Date     Version    Author      Modification
    78. * ------------------------------------------------------------
    79. *       2022/03/09    1.0                            Create        
    80. **********************************************************************/
    81. void Object::operator delete[] (void* p)
    82. {
    83.     free(p);
    84. }
    85.  
    86. /**********************************************************************
    87. * Function:        Object::operator ==()
    88. * Description:     ==重载函数
    89. * Table Accessed: 
    90. * Table Updated:  
    91. * Input:            
    92. * Output:           
    93. * Return:          
    94. * Others:           
    95. * Modify   Date     Version    Author      Modification
    96. * ------------------------------------------------------------
    97. *       2022/03/09    1.0                            Create        
    98. **********************************************************************/
    99. bool Object::operator == (const Object& obj)
    100. {
    101.     return (this == &obj);
    102. }
    103.  
    104. /**********************************************************************
    105. * Function:        Object::operator !=()
    106. * Description:     !=重载函数
    107. * Table Accessed: 
    108. * Table Updated:  
    109. * Input:            
    110. * Output:           
    111. * Return:          
    112. * Others:           
    113. * Modify   Date     Version    Author      Modification
    114. * ------------------------------------------------------------
    115. *       2022/03/09    1.0                            Create        
    116. **********************************************************************/
    117. bool Object::operator != (const Object& obj)
    118. {
    119.     return (this != &obj);
    120. }
    121.  
    122. /**********************************************************************
    123. * Function:        Object::~Object()
    124. * Description:     析构函数
    125. * Table Accessed: 
    126. * Table Updated:  
    127. * Input:            
    128. * Output:           
    129. * Return:          
    130. * Others:           
    131. * Modify   Date     Version    Author      Modification
    132. * ------------------------------------------------------------
    133. *       2022/03/09    1.0                            Create        
    134. **********************************************************************/
    135. Object::~Object()
    136. {
    137.  
    138. }
    139.  
    140. }

    6、小结

    • Object类是DTLib中数据结构类的顶层父类
    • Object类用于统一动态内存申请的行为
    • 在堆中创建Object子类的对象，失败时返回NULL值
    • Object类为纯虚父类，所有子类都能进行动态类型识别

     

    十三、类族结构的进化

    1、遵循经典设计准则

    • DTLib 中的所有类位于单一的继承树

            

    2、改进的关键点

    • Exception类继承自Object类
      • 堆空间中创建异常对象失败时，返回NULL指针
    • 新增InvalidOperationException异常类
      • 成员函数调用时，如果状态不正确则抛出异常
    • SmartPointer 类继承自Object类
      • 堆空间中创建智能指针对象失败时，返回NULL指针

    3、编程实验：类族结构的进化

    Exception.cpp

    Exception.h

    与上一个相同

    4、DTLib 的开发方式和注意事项

    • 迭代开发
      • 每次完成一个小的目标，持续开发，最终打造可复用类库
    • 单—继承树
      • 所有类都继承自Object，规范堆对象创建时的行为
    • 只抛异常，不处理异常
      • 使用THROW_EXCEPTION抛出异常，提高可移植性
    • 弱耦合性
      • 尽量不使用标准库中的类和函数，提高可移植性

    5、第一阶段学习总结

    • 数据结构与算法之间的关系
    • 算法效率的度量方法
    • DTLib的基础设施构建
      • 顶层父类
      • 智能指针
      • 异常类
  • 相关阅读:
    LLVM之父Chris Lattner：编译器的黄金时代
    JAVA集合框架工具类自定义Collections集合方法
    linux（ARM）架构下的mysql安装使用（完整版）
    2-8：Http响应头content-type内容详解
    以太网转RS485串口计数器WiFI模块 LED灯光控制器IBF165
    2.3 为何使用Pthreads
    开源项目在线化 中文繁简体转换/敏感词/拼音/分词/汉字相似度/markdown 目录
    连锁超市如何部署远程监控系统
    在react中使用event(事件对象)，如何使用，注意事项和react中如何定义和使用函数？
    Linux-查询目录下包含的目录数或文件数
  • 原文地址：https://blog.csdn.net/qq_38426928/article/details/125455461