cc38b_demo_C++_异常_(2)txwtech在异常中使用虚函数-多态

//cc38b_demo,21days_C++_异常_(2)txwtech20200121在异常中使用虚函数-多态

//--异常层次结构
//*异常的类-创建自己的异常类
//*异常派生-就是继承
//*异常中的数据：数据成员

//*按引用传递异常

//
//*->在异常中使用虚函数/可以使用多态，简化catch

 //cc38b_demo,21days_Cpp_异常_(2)txwtech20200121在异常中使用虚函数-多态

 //--异常层次结构
 //*异常的类-创建自己的异常类
 //*异常派生-就是继承
 //*异常中的数据：数据成员

 //*按引用传递异常

 //
 //*->在异常中使用虚函数/可以使用多态，简化catch

 #include <iostream>
 using namespace std;
 const int DefaultSize = ;
 class Array//数组类，类似动态数组vector
 {
 public:
     Array(int itsSize = DefaultSize);
     ~Array() { delete[] pType; }//删除[]数组指针
     //运算符重载
     //下标运算符重载
     int& operator[](int offSet);//非-常函数
     const int& operator[](int offSet) const;//常函数
     //访问器，accessors
     int GetitsSize() const { return itsSize; }
     //做异常类
     class xBoundary {};
     class xSize
     {
     public:
         xSize() {}
         xSize(int size) :itsSize(size) {}
         ~xSize() {};
         int GetSize() { return itsSize; }

         ////*->在异常中使用虚函数

         virtual void PrintError()
         {
             cout << "下标发生错误： " << itsSize << endl;
         }
     //private:
     protected:
         int itsSize;

     };
     //class xZero {};
     //class xNegative {};
     //class xTooSmall {};
     //class xTooBig {};

     //通过继承实现异常的层次结构,好处是什么？得到更详细的异常信息

     class xZero :public xSize
     {
     public:
         xZero(int size) :xSize(size) {}
         virtual void PrintError()
         {
             cout << "下标不能是0"<< endl;
         }
     };
     class xNegative :public xSize
     {
     public:
         xNegative(int size) :xSize(size) {}
         virtual void PrintError()
         {
             cout << "下标不能是负数" <<xSize::itsSize<< endl;
         }
     };
     class xTooSmall :public xSize
     {
     public:
         xTooSmall(int size) :xSize(size) {}
         virtual void PrintError()
         {
             cout << "下标不能小于10:当前是：" << xSize::itsSize << endl;
         }
     };
     class xTooBig :public xSize
     {
     public:
         xTooBig(int size) :xSize(size) {}
         virtual void PrintError()
         {
             cout << "下标不能>3000" << xSize::itsSize << endl;
         }//catch就可以简化了
     };
 private:
     int *pType;
     int itsSize;
 };
 int& Array::operator[](int offset)//非-常函数
 {
     int size = this->GetitsSize();
     if (offset >=  && offset < size)
         return pType[offset];
     throw xBoundary(); //xBoundary后面记得加括号()
 }
 const int& Array::operator[](int offset) const//常函数
 {
     int size = this->GetitsSize();
     if (offset >=  && offset < size)
         return pType[offset];
     //异常类，用着下标操作中
     throw xBoundary(); //xBoundary后面记得加括号()
 }

 Array::Array(int size) :itsSize(size) //
 {
     if (size == )
         throw xZero(size);
     else if (size < )
         throw xNegative(size);
     else if (size > )
         throw xTooBig(size);
     else if (size < )
         throw xTooSmall(size);
     pType = new int[size];//动态创建数组，放在pType指针
     for (int i = ; i < size; i++)
         pType[i] = ;
 }

 int main()
 {

     try
     {
         Array a;
         Array intArray();
         //Array b(-12);
         //Array b(30000);
         Array b();//6<10发生异常，太小
         for (int j = ; j < ; j++)
         {
             intArray[j] = j;
             cout << "intArray[" << j << "]okay..." << endl;
         }

     }
     catch (Array::xBoundary)
     {
         cout << "下标越界了" << endl;
     }
     //简化有继承关系的，实现多态
     catch (Array::xSize& exp)
     {
         exp.PrintError();
     }
     //catch (Array::xZero)  //构造函数里面throw与catch里面的顺序需要一致
     //{
     //    cout << "下标不能为0" << endl;
     //}
     //
     //catch (Array::xNegative theException)//构造函数里面throw与catch里面的顺序需要一致
     //{
     //    cout << "下标不能是负数: " << theException.GetSize() << endl;
     //}
     //
     //catch (Array::xTooBig theException)//构造函数里面throw与catch里面的顺序需要一致
     //{
     //    cout << "下标不能>3000:" << theException.GetSize() << endl;
     //}
     //
     //catch (Array::xTooSmall theException)//构造函数里面throw与catch里面的顺序需要一致
     //{
     //    cout << "下标不能<10，当前是:" << theException.GetSize() << endl;
     //}
     catch (...)//catch需要有顺序，...放到最后
     {
         cout << "发生未知异常" << endl;
     }
     cout << "Done." << endl;
     getchar();
     //system("pause");
     return ;
 }