C++中的异常实例详解

//第2点
T& operator[](int index)
{
	//问题: 当访问的下标index超出容器的范围，此时该返回什么值?
    //解决方案: 可以再传一个参数，用于获取真正的结果(当输出型参数), 返回值就用于判断是否正确的返回了. 
    //实际上还是很麻烦
}

try
{
    //保护代码(可能会抛出异常的代码)
}catch(ExceptionType e1)
{
    //处理异常
}catch(ExceptionType e2)
{
    //处理异常
}catch(ExceptionType eN)
{
    //处理异常
}

//代码演示：f3()中抛出异常，该异常会被f1()捕捉，而在main函数中的catch是无法捕捉到的
void f3()
{
	throw 123;
}
void f2()
{
    f3();
}
void f1()
{
    try
    {
        f2();
        cout << "f1() not catched Exception!" << endl;
    }catch(int& err)
    {
        cout << "f1()-err: " << err << endl;
    }
}

int main()
{
    try
    {
        f1();
        cout << "main not catched Exception!" << endl;
    }catch(int& err)
    {
        cout << "main-err: " << err << endl; 
    }
    return 0;
}

//在SecondThrowException()函数中我们要delete[]动态开辟(new出来)的空间，
//如果不使用异常的重新抛出的话，就会造成内存泄漏问题 (也可以使用RAII)
void FirstThrowException()
{
    throw "First throw a exception!";
}

void SecondThrowException()
{
    int* arr = new int[10];
    try
    {
        FirstThrowException();
    }catch(...)
    {
        cout << "Delete[] arr Success!" << endl;
        delete[] arr;
        throw;
    }
}

void SoluteException()
{
    try
    {
        SecondThrowException();
    }catch(const char* err)
    {
        cout << err << endl;
    }
}

int main()
{
    SoluteException();
    return 0;
}

class MyException
{
public:
	MyException(string errmsg, int id)
		:_errmsg(errmsg),
		 _id(id)
	{}
	
	virtual string what() const = 0;	//必须放到public下才能让类外定义的成员访问到
protected:
	int _id;		//错误码
	string _errmsg;	//存放错误信息
	//list<StackInfo> _traceStack;	//存放调用链的信息
    //...
};

class CacheException : public MyException
{
public:
	CacheException(string errmsg, int id)
		:MyException(errmsg, id)
	{}

	virtual string what() const
	{
		return "CacheException!: " + _errmsg;
	}
};

class NetworkException : public MyException
{
public:
	NetworkException(string errmsg, int id)
		:MyException(errmsg, id)
	{}

	virtual string what() const
	{
		return "NetworkException!: " + _errmsg;
	}
};

class sqlException : public MyException
{
public:
	SqlException(string errmsg, int id)
		:MyException(errmsg, id)
	{}

	virtual string what() const
	{
		return "SqlException!: " + _errmsg;
	}
};

int main()
{
	try
	{
		//抛出任意的派生类对象
		throw SqlException("sql open failed", 10);
	}
    catch (const MyException& e)	//只需要捕获基类对象
	{
		cout << e.what() << endl;	//这里实际上完成了一个多态
	}
	catch (...)	//走到这里说明出现未知异常
	{
		cout << "Unknown Exception!" << endl;
	}

	return 0;
}

void func1() throw(); //表示该函数不会抛异常
void func2() noexcept; //等价于throw()  表示该函数不会抛异常
void func3() throw(std::bad_alloc);	//表示该函数只会抛出bad_alloc的异常
void func4() throw(int, double, string); //表示该函数会抛出int/double/string类型中的某种异常

int main()
{
	try
    {
        vector<int> v(5);
        v.at(5) = 0;	//v.at(下标) = v[下标] + 抛异常
    }
    catch(const exception& e)
    {
        cout << e.what() << endl;
    }
    catch(...)
    {
		cout << "Unknown Exception!" << endl;        
    }
}