C++异常之五异常和继承

异常和继承

异常也是类，我们可以创建自己的异常类，在异常中可以使用（虚函数，派生，引用传递和数据成员等），

下面用一个自制的数组容器Vector，在对Vector初始化时来对Vector的元素个数进行有效检查。以此来说明继承与异常的使用关系。

运行下方代码，Vector对象传不同参数进去，会触发相应的异常的条件：

1）　size < 0 抛出异常 errNegativeException 类

2）　size = 0 抛出异常 errZeroException 类

3）　size > 1000 抛出异常 errTooBigException 类

4）　size < 10 抛出异常 errToosmallException 类

5）　errSizeException 类是以上的父类，定义 virtual void printError() const 的虚函数，以多态的形式来输出错误。

  1 #include <iostream>

  2

  3 using namespace std;

  4

  5 //errSizeException 父类

  6 class errSizeException

  7 {

  8 public:

  9     errSizeException(int size)

 10     {

 11         m_size = size;

 12     }

 13     virtual void printError()const                                        //虚函数实现多态

 14     {

 15         cout << "errSizeException size：" << m_size << endl;

 16     }

 17

 18 protected:

 19     int m_size = 0;

 20 };

 21

 22 //index < 0 抛出异常 errNegativeException 类

 23 class errNegativeException :public errSizeException

 24 {

 25 public:

 26     errNegativeException(int size) :errSizeException(size) {}       //使用初始化列表对子类初始化

 27     const virtual void printError()

 28     {

 29         cout << "errNegativeException size：" << m_size << endl;

 30     }

 31 };

 32

 33 //index = 0 抛出异常 errZeroException 类

 34 class errZeroException :public errSizeException

 35 {

 36 public:

 37     errZeroException(int size) :errSizeException(size) {}             //使用初始化列表对子类初始化

 38     const virtual void printError()

 39     {

 40         cout << "errZeroException size：" << m_size << endl;

 41     }

 42 };

 43

 44 //index > 1000 抛出异常 errTooBigException  类

 45 class errTooBigException :public errSizeException

 46 {

 47 public:

 48     errTooBigException(int size) :errSizeException(size) {}            //使用初始化列表对子类初始化

 49     const virtual void printError()

 50     {

 51         cout << "errTooBigException size：" << m_size << endl;

 52     }

 53 };

 54

 55 //index < 10 抛出异常 errToosmallException  类

 56 class errToosmallException :public errSizeException

 57 {

 58 public:

 59     errToosmallException(int size) :errSizeException(size) {}           //使用初始化列表对子类初始化

 60     const virtual void printError()

 61     {

 62         cout << "errToosmallException size：" << m_size << endl;

 63     }

 64 };

 65

 66

 67 class Vector

 68 {

 69 public:

 70     Vector(int szie);                                              //带参构造函数

 71     ~Vector()                                                     //析构函数

 72     {

 73         if (m_base)

 74         {

 75             delete[] m_base;

 76             m_len = 0;

 77         }

 78     }

 79

 80     int getLength()                                              //获取内部储存元素的个数

 81     {

 82         return m_len;

 83     }

 84

 85     int& operator[](int index)                                    //下标重载

 86     {

 87         return m_base[index];

 88     }

 89 private:

 90     int* m_base = NULL;                                            //存储空间指针

 91     int m_len = 0;                                                 //长度

 92 };

 93

 94 Vector::Vector(int len)

 95 {

 96     if (len < 0)

 97     {

 98         throw errNegativeException(len);                    //抛出临时对象，带有长度参数进行构造

 99     }

100     else if (len = 0)

101     {

102         throw errZeroException(len);                        //抛出临时对象，带有长度参数进行构造

103     }

104     else if (len > 1000)

105     {

106         throw errTooBigException(len);                      //抛出临时对象，带有长度参数进行构造

107     }

108     else if (len < 10)

109     {

110         throw errToosmallException(len);                    //抛出临时对象，带有长度参数进行构造

111     }

112     m_len = len;

113     m_base = new int[m_len];

114 }

115

116

117 int main()

118 {

119     try

120     {

121         Vector _V(-1);                                           //传：-1、0、1001、1 四个参数进去，会抛出四个异常

122

123         for (int i = 0; i < _V.getLength(); i++)

124         {

125             _V[i] = i + 10;

126             printf("_V[%d]：%d\n", i, _V[i]);

127         }

128     }

129     catch (const errSizeException& err)                           //父类，由多态特性与其子类进行匹配

130     {

131         err.printError();

132     }

133

134     return 0;

135 }