从两个例子来看C++的异常和Java中的异常【原】

例子一：

#include "stdafx.h"
/*
 c++和java的异常机制的不同
*/

class Excep{
public:
    int division(int a,int b){
        try{
        //-----------------------------------------
         if(b==0)
             throw new std::exception();
         //在Java中不需要用户来显示的throw一个异常而会自动抛出异常
        //-----------------------------------------
         std::cout<<"hello"<<std::endl;
         //在Java下面的这个return编译不过，是因为，因为a/b的时候抛出了异常
         //而这个return其实没有return任何值，其实return就是我们自己看也不是一条语句
         //而是两条语句，是1）a/b 2)return a/b 在运行语句1的时候就直接抛出异常了，下面的
         //return就不会执行了，而函数的返回值要求是int型，所以出错，但是这在编译时就能
         //检查出来也太强了吧,不过在c++中对函数的返回值检查是不是很严格，即使是在main
         //中声明为int,但是你如果把return 0注释掉的话也不会出错，看来java是强类型语言中
         //最强的一个，至少在类型检查上比c++要强
          return a/b;
        }
        catch(std::exception& e){
            std::cerr<<e.what()<<std::endl;
        }
        catch(){
            std::cerr<<"exception"<<std::endl;
        }
    }
};

int _tmain(int argc, _TCHAR* argv[])
{
    Excep e;
    e.division(5,0);
    std::cout<<"finish"<<std::endl;
    /*
    try 
   {
      locale loc( "test" );
   }
   catch ( exception &e ) 
   {
      cerr << "Caught " << e.what( ) << endl;
      cerr << "Type " << typeid( e ).name( ) << endl;
   };
   */

    return 0;
}

/*
上面的代码是MSDN中的一段例子，我们看到它没有显示的throw一个异常，但是实际上
在local的类实现中抛出了异常。跟踪xloacl源代码会发现
explicit __CLR_OR_THIS_CALL locale(const char *_Locname,
        category _Cat = all)     // construct from named locale for category
        : _Ptr(_NEW_CRT _Locimp)
        {    // construct a locale with named facets
        _TRY_BEGIN
        _Init();
        _BEGIN_LOCINFO(_Lobj(_Cat, _Locname))
            if (_Lobj._Getname().compare("*") == 0)
                _THROW(runtime_error, "bad locale name");
            _Locimp::_Makeloc(_Lobj, _Cat, _Ptr, 0);
        _END_LOCINFO()
        _CATCH_ALL
        _DELETE_CRT(_Ptr->_Decref());
        _RERAISE;
        _CATCH_END
        }
        顺便提一句，看大段的C++代码想搞清楚一个很大的类的结构用Notepad++还是很方便的

*/

 

例子二：

class ClassTest
{
    public static void main(String[] args)
    {
        Point pt=new Point();
        Class c1=pt.getClass();
        System.out.println(c1.getName());
        //注意：在Java中这里如果不加try catch就会编译出错
                 //因为，类Class的static方法forName声明为有异常抛出
                //所以就一定要捕获，可以不抛出异常，但是一定要做好捕获的
                //装备，否则连编译都无法通过，所以说Java的异常设计是非常
                //非常的严格，这对于写出健壮的代码也是非常有好处的
                 //甚至在interface和abstract class中尽管没有实现也声明
                 //有特定类型的异常会抛出，这也成了接口的一部分，很好！
                 //相比来说，C++的异常的设计非常糟糕，编译器的支持也不好
        try
        {
            Class c2=Class.forName("Point");
            System.out.println(c2.getName());
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        
        Class c3=Point.class;
        System.out.println(c3.getName());
        
        Class c4=int.class;
        System.out.println(c4.getName());
        
        Class c5=Integer.TYPE;
        System.out.println(c5.getName());
        
        Class c6=Integer.class;
        System.out.println(c6.getName());
          }
 }

class Point
{
   int x,y;
}