从两个例子来看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;
}

转载于:https://www.cnblogs.com/NeuqUstcIim/archive/2009/01/18/1377920.html