您的位置：首页 > 编程语言 > C语言/C++

C++、Java和C#中的异常处理

2008-06-09 00:53 555 查看

来源：温少的日志

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

throw 100;

try

{

// do something

} catch (int num)

{

// do something

}

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

class exception

{

public:

exception( );

exception(const char *const&);

exception(const char *const&, int);

exception(const exception&);

exception& operator=(const exception&);

virtual ~exception( );

virtual const char *what( ) const;

};

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

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

//可以抛出任何异常

void f()

{

throw 100;

}

//描述该函数不会抛出任何异常

void f() throw()

{

}

//描述该函数会抛出int或者char*类型的异常

void f() throw(int, char*)

{

// do something

}

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

void f() throw(int, char*)

{

throw "100";

}

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

class file_exception

{}

class network_exception

{}

class newwork_file_exception : public file_exception, public network_exception

{}

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

try

{

// do something

} catch (

)

{ //捕捉所有的异常

// do something

}

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

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

public class Throwable implements Serializable

{

public Throwable();

public Throwable(String message);

public Throwable(String message, Throwable cause); //@since 1.4

public Throwable(Throwable cause); //@since 1.4

public String getMessage();

public String getLocalizedMessage(); //@since JDK1.1

public Throwable getCause(); //@since 1.4

public synchronized Throwable initCause(Throwable cause); //@since 1.4

public String toString();

public void printStackTrace();

public void printStackTrace(PrintStream s);

public void printStackTrace(PrintWriter s); //@since JDK1.1

private void printStackTraceAsCause(PrintWriter s,

StackTraceElement[] causedTrace);

public synchronized native Throwable fillInStackTrace();

public StackTraceElement[] getStackTrace(); //@since 1.4

public void setStackTrace(StackTraceElement[] stackTrace); //@since 1.4

}

Throwable下分Exception和Error。

public class Exception extends Throwable

{}

public class Error extends Throwable

{}

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

Java divides exceptions in two categories: checked exceptions and unchecked exceptions. Exceptions that are not "checked" by the compiler are called unchecked exceptions; exceptions that are "checked" by the compiler are called checked exceptions. The compiler will not compile a file if it contains a method where a checked exception may occur and the method does not handle the checked exception in a catch block or list it in the method header. The classes

RuntimeException

Error

and their subclasses are unchecked exceptions. All other exception classes are checked exceptions.

If a checked exception might occur in a method and the method does not have

catch

block to handle the checked exception, then the checked exception must be declared in the method header using a

throws

clause. For example, if an

IOException

might occur in method

readInteger

and

readInteger

doesn't handle it, then

readInteger

must have the following header:

public int readInteger() throws IOException {

}

readInteger

does not list

IOException

in its

throws

clause, compilation will fail with an error message about checked exceptions. Unchecked exceptions may be listed in a

throws

clause, but the compiler does not require it.

In the following code, neither method

readInteger

nor method

main( )

catches

IOException

so they both list

IOException

in their

throws

clauses. When method

main

throws an

IOException

, the exception object is passed to the Java Virtual Machine (JVM). The JVM displays the exception information and terminates the program.

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:

import java.io.*;

/**
* This class provides a method that reads an integer from the
* standard input.
*
* @author author name
* @version 1.0.0
*/
public class IntegerReaderThrowsException  {

private static BufferedReader  stdIn =
new BufferedReader(new  InputStreamReader(System.in));

private static PrintWriter  stdErr =
new PrintWriter(System.err, true);

private static PrintWriter  stdOut =
new PrintWriter(System.err, true);

/**
* Tests method <code>readInteger</code>
*
* @param args  not used
* @throws IOException if error reading from standard input.
*/
public static void main (String[] args) throws IOException {

stdOut.println("The value is: " + readInteger());
}

/**
* Reads an integer from the standard output.
*
* @return the <code>int</code> value.
* @throws IOException if error reading from standard input.
*/
public static int  readInteger() throws IOException {

do  {
try  {
stdErr.print("Enter an integer> ");
stdErr.flush();

return Integer.parseInt(stdIn.readLine());

} catch (NumberFormatException  nfe)  {
stdErr.println("Invalid number format");
}
}  while (true);
}
}

Listing 4 IntegerReaderThrowsException.java

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

public void f()

{

throw new RuntimeException(); //正确

}

public void f()

{

throw new Error(); //正确

}

以下的代码编译出错

public void f()

{

throw new Exception();

}

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

public WfException extends Exception

{}

public void f() throws WfException

{

throw new WfException();

}

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

public void f() throws WfException

{

try

{

// do something

} catch (Exception e)

{

throw new WfException ("", e);

}

}

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

try

{

// do something

} catch (Exception e)

{

// do something

} finally

{

// do something

}

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

{

// do something

}

catch (Exception e)

{

// do something

}

finally

{

// do something

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航