C++异常小练习异常对象与多态

た入场券 2023-10-18 18:24 96阅读 0赞

#include<iostream>
    using namespace std;
    
    //自定义异常类
    class eSize
    {
    public:
    	eSize(int size)
    	{
    		this->size = size;
    	}
    	virtual void printErr()
    	{
    		cout << "eSize Error" << endl;
    	}
    private:
    	int size;
    };
    
    class eZero :public eSize
    {
    public:
    	eZero(int size):eSize(size)
    	{
    		
    	}
    	virtual void printErr()
    	{
    		cout << "eZero Error" << endl;
    	}
    };
    class eTooBig :public eSize
    {
    public:
    	eTooBig(int size) :eSize(size)
    	{
    
    	}
    	virtual void printErr()
    	{
    		cout << "eTooBig Error" << endl;
    	}
    };
    class eTooSmall :public eSize
    {
    public:
    	eTooSmall(int size) :eSize(size)
    	{
    
    	}
    	virtual void printErr()
    	{
    		cout << "eTooSmall Error" << endl;
    	}
    };
    class eNegative :public eSize
    {
    public:
    	eNegative(int size) :eSize(size)
    	{
    
    	}
    	virtual void printErr()
    	{
    		cout << "eNegative Error" << endl;
    	}
    };
    //数组类，重载[]
    class my_array
    {
    public:
    	my_array(int size)
    	{
    		this->size = size;
    		p = new int[size];
    
    		if (size < 0)
    		{
    			throw eNegative(size);
    		}
    		if (size == 0)
    		{
    			throw eZero(size);
    		}
    		if (size > 100)
    		{
    			throw eTooBig(size);
    		}
    		if (size > 0 && size< 10)
    		{
    			throw eTooSmall(size);
    		}
    	}
    	my_array(const my_array& obj)
    	{
    		this->size = obj.size;
    		p = new int[obj.size];
    	}
    	~my_array()
    	{
    		if (p != NULL)
    		{
    			delete p;
    			p = NULL;
    			size = 0;
    		}
    	}
    	my_array& operator=(const my_array& obj)
    	{
    		if (p != NULL)
    		{
    			delete p;
    			p = NULL;
    			size = 0;
    		}
    		this->size = obj.size;
    		p = new int[obj.size];
    
    	}
    	int& operator [](int index)
    	{
    		return p[index];
    	}
    private:
    	int *p;
    	int size;
    };
    
    int main()
    {
    	int size = 10000;
    	try
    	{
    		my_array A(size);
    	}
    	catch (eSize& e)//异常对象的多态性质，虽然严格的按照类型匹配，但是可以捕获其派生类
    	{
    		e.printErr();
    	}
    	catch (...)
    	{
    		cout << "Unknow Error" << endl;
    	}
    	system("pause");
    	return 0;
    }