异常在类及其对象中的应用

#include <iostream>
#include <vector>

using namespace std;

class Array
{
public:
	// 有一个参数的构造函数
    Array(int len);

    // 基类
    class eSize
    {
    public:
		
	eSize(int size):_size(size)
	{

	}
	virtual void print() = 0;
	
    protected:
        int _size;
    };
	
    // 内部类
    class eLessZero : public eSize
    {
    public:
        eLessZero(int size):eSize(size)
        {

        }
        void print()
        {
            cout << "参数小于0：" << _size << endl;
        }
    };

    class eZero : public eSize
    {
    public:
        eZero(int size):eSize(size)
        {

        }
        void print()
        {
            cout << "参数等于0：" << _size << endl;
        }
    };

    class eTooBig : public eSize
    {
    public:
        eTooBig(int size):eSize(size)
        {

        }
        void print()
        {
            cout << "参数大于10000：" << _size << endl;
        }
    };
};

// throw 抛基础数据类型， ==>  可以抛自定义数据类型
Array::Array(int len)
{
    if (len < 0)
		// 可参照对象初始化列表
		// 这是一个匿名对象
        // Test3 t = Test3(a,20);
		// Test3(a,20)是个变量，变量名是t 
        // 相当于创建了个对象，又将其释放
		// Test3(a, 20);是个对象
		// 对于t2的a和b还被初始化
		// 在构造函数里调用其他的构造函数，但是无法达到初始化的目的，因为刚被创建就被释放了
        throw eLessZero(len);
    else if (len == 0)
        throw eZero(0);
    else if (len >= 10000)
        throw eTooBig(len);
}


int main()
{
    try
    {
        Array a(100000);
    }
    catch(Array::eSize &e)
    {
        e.print();   // 多态
    }
//    catch(Array::eLessZero &e)
//    {
//        e.print();
//    }
//    catch(Array::eZero &e)
//    {
//        e.print();
//    }
//    catch(Array::eTooBig &e)
//    {
//        e.print();
//    }

    vector<int> v;
    try
    {
        // v[1] = 10;
        v.at(1) = 10;
    }
    catch(int e)
    {

    }
    catch(out_of_range &e)
    {
        cout << e.what() << endl;
    }

    return 0;
}