简单了解C++、Java和C#中的异常处理

转自：http://blog.sina.com.cn/s/blog_4daeca9c01000auq.html

C++ 中异常：
1、可以抛出任何异常。虽然标准C++定义了std::exception类，但throw的对象可以是任何对象。包括int、char*等。例如：

throw100;

try {
//dosomething
}

catch(intnum) {
//dosomething
}

但是，C++标准库中抛出的所有异常，都是派生自std::exception类。
std::exception定义如下:

classexception {
public:
exception();
exception(constchar*const&);
exception(constchar*const&,int);
exception(constexception&);
exception&operator=(constexception&);
virtual~exception();
virtualconstchar*what()const;
};

2、标准C++中，是没有finally子句。熟悉Java和C#的朋友，也许会觉得奇怪！没有finally子句，使用的确不方便。

3、C++中，函数的声明，缺省时可以抛出任何异常的，也可以使用异常规范来约束函数抛出的异常，如：

//可以抛出任何异常
voidf() {
throw100;
}

//描述该函数不会抛出任何异常
voidf()throw() {
}

//描述该函数会抛出int或者char*类型的异常
voidf()throw(int,char*) {
//dosomething
}

但是，C++中的异常规范不是很可靠。如下的代码也是可以编译通过的，但是编译器会给出警告。

voidf()throw(int,char*) {
throw"100";
}

4、C++的异常可以派生自多个异常基类。这一个特性使得难以分类的异常容易处理，例如网络文件的异常：

classfile_exception {}
classnetwork_exception {}
classnewwork_file_exception:publicfile_exception,publicnetwork_exception {}

5、捕捉所有异常的语法。C++中，不是单根继承的，所以你不能，如同Java或者C#那样，通过捕捉某个基类来捕捉所有的异常。

try {
//dosomething
}catch( ) {//捕捉所有的异常
//dosomething
}

总结，C++中，命名空间和异常规范是作为针对大规模程序设计而引入的特性。但是由于C++中没有垃圾收集机制，异常造成了资源管理变得非常复杂。在C++中，编写异常安全的代码，是十分困难的。

Java 中的异常：
1、可以抛出任何派生自了Throwable的类。Throwable类的定义如下：

publicclassThrowableimplementsSerializable {
publicThrowable();
publicThrowable(Stringmessage);
publicThrowable(Stringmessage,Throwablecause);//@since1.4
publicThrowable(Throwablecause);//@since1.4
publicStringgetMessage();
publicStringgetLocalizedMessage();//@sinceJDK1.1
publicThrowablegetCause();//@since1.4
publicsynchronizedThrowableinitCause(Throwablecause);//@since1.4
publicStringtoString();
publicvoidprintStackTrace();
publicvoidprintStackTrace(PrintStreams);
publicvoidprintStackTrace(PrintWriters);//@sinceJDK1.1
privatevoidprintStackTraceAsCause(PrintWriters,
StackTraceElement[]causedTrace);
publicsynchronizednativeThrowablefillInStackTrace();
publicStackTraceElement[]getStackTrace();//@since1.4
publicvoidsetStackTrace(StackTraceElement[]stackTrace);//@since1.4
}

Throwable下分Exception和Error。

publicclassExceptionextendsThrowable {}
publicclassErrorextendsThrowable {}

而Exception中，有一个特别的派生类，RuntimeException，如下：
public class RuntimeException extends Exception {}
类图如下：

2、Java中，也使用异常规范，并且在整个基础类库中都使用。Java是基于JVM运行，但是JVM本身就抛出异常，也就是，所有的方法都可能抛出异 常。因此，Java编译器编译不检查Error和RuntimeException。与C++不同，没有异常规范，缺省不允许抛出任何非 RuntimeException和Error的异常。如下：

publicvoidf() {
thrownewRuntimeException();//正确
}

publicvoidf() {
thrownewError();//正确
}

以下的代码编译出错

publicvoidf() {
thrownewException();
}

使用异常规范的正确例子：

publicWfExceptionextendsException {}

publicvoidf()throwsWfException {
thrownewWfException();
}

3、Throwable、Exception、RuntimeException中部分成员，是在不同的JDK版本中添加的，编写代码的时候需要注意。如下的代码不能在JDK 1.3中编译通过：

publicvoidf()throwsWfException {
try {
//dosomething
}catch(Exceptione) {
thrownewWfException("",e);
}
}

4、Java中的try语法，包括finally子句。如下：

try {
//dosomething
}catch(Exceptione) {
//dosomething
}finally {
//dosomething
}

C# 中的异常：
1、C#异常的局限性。C#是基于CLR运行的，由于CLR需要支持多种语言，其异常的实现受到了较大的局限。一个重要的特征就是没有异常规范，很多人对此很失望！Anders Hejlsberg曾专门发表过文章，说明为什么C#不支持异常规范，说得也很有道理。但是，没有异常规范的C#，变得简单，但也更容易犯错误，在这一点上，我更喜欢Java，而不喜欢C#的方式。没有异常规范，编译器就不会帮我们检查代码，是否做了try ... catch处理。

2、异常的结构。在.NET Framework中，所有的异常派生自System.Exception基类。其下有两个子类：SystemException和 ApplicationException。自行编写异常类，不建议直接派生自Exception类，而是应该派生自 ApplicationException。

3、C#犹如Java，也支持finally的写法。如：

try
{
//dosomething
}
catch(Exceptione)
{
//dosomething
}
finally
{
//dosomething
}