精华内容
参与话题
问答
  • java关键字catch

    千次阅读 2013-09-02 21:19:59
    catch 关键字   catch 关键字用来在 try-catch 或 try-catch-finally 语句中定义异常处理块。   示例 try { } catch ( e) { } try { } ca

    catch 关键字

     

    catch 关键字用来在 try-catch 或 try-catch-finally 语句中定义异常处理块。

     

    示例
    
       try
    
       {
    
          <可能引发异常的块>
    
       }
    
       catch (<java.lang.Exception 或子类> e)
    
       {
    
          <处理异常 e 的代码>
    
       } 
    
       try
    
       {
    
          <可能引发其他异常的块>
    
       }
    
       catch (FooException e)
    
       {
    
          <处理 FooException e 的代码>
    
       }
    
       catch (BarException e)
    
       {
    
          <处理 BarException e 的代码>
    
       } 
    
       try
    
       {
    
          <可能引发异常的块>
    
       }
    
       catch (<java.lang.Exception 或子类> e)
    
       {
    
          <处理异常 e 的代码>
    
       }
    
       finally
    
       {
    
          <有异常或无异常情况下都执行的语句>
    
       }
    
    /*
    
    注释
    
    开始和结束标记 { 和 } 是 catch 子句语法的一部分,即使该子句只包含一个语句,也不能省略这两个标记。
    
    每个 try 块都必须至少有一个 catch 或 finally 子句。
    
    如果某个特定异常类未被任何 catch 子句处理,该异常将沿着调用栈递归地传播到下一个封闭 try 块。如果任何封闭 try 块都未捕获到异常,Java 解释器将退出,并显示错误消息和堆栈跟踪信息。
    
    */
    


     

    展开全文
  • java中try 与catch的使用

    万次阅读 多人点赞 2017-10-08 21:38:43
    }catch(Exception e){ //异常处理 } 代码区如果有错误,就会返回所写异常的处理。   首先要清楚,如果没有try的话,出现异常会导致程序崩溃。 而try则可以保证程序的正常运行下去,比如说: try{ int i = 1/0; }...

    try{
    //
    代码区
    }catch(Exception e){
    //
    异常处理
    }
    代码区如果有错误,就会返回所写异常的处理。

     

    首先要清楚,如果没有try的话,出现异常会导致程序崩溃。
    try则可以保证程序的正常运行下去,比如说:

    try{
    int i = 1/0;
    }catch(Exception e){
    ........
    }


    一个计算的话,如果除数为0,则会报错,如果没有try的话,程序直接崩溃。用try的话,则可以让程序运行下去,并且输出为什么出错!

    try catch 是捕捉try部分的异常,当你没有trycatch的时候,如果出现异常则程序报错,加上trycatch,出现异常程序正常运行,只是把错误信息存储到Exception里,所以catch是用来提取异常信息的,你可以在Catch部分加上一句System.out.println(e.ToString());,如果出现异常可以把异常打印出来

     

    java的异常处理机制(try…catch…finally)

    1 引子
    try…catch…finally
    恐怕是大家再熟悉不过的语句了,而且感觉用起来也是很简单,逻辑上似乎也是很容易理解。不过,我亲自体验的教训告诉我,这个东西可不是想象中的那么简单、听话。不信?那你看看下面的代码,猜猜它执行后的结果会是什么?不要往后看答案、也不许执行代码看真正答案哦。如果你的答案是正确,那么这篇文章你就不用浪费时间看啦。

    public class TestException
    {
        public TestException()
        {
        }
        boolean testEx() throws Exception
        {
            boolean ret = true;
            try
            {
                ret =testEx1();
            }
            catch (Exception e)
            {
                System.out.println("testEx,catch exception");
                ret =false;
                throwe;
            }
            finally
            {
                System.out.println("testEx,finally; return value=" + ret);
                returnret;
            }
        }
        boolean testEx1() throws Exception
        {
            boolean ret = true;
            try
            {
                ret =testEx2();
                if(!ret)
                {
                    returnfalse;
                }
                System.out.println("testEx1,at the end of try");
                returnret;
            }
            catch (Exception e)
            {
                System.out.println("testEx1,catch exception");
                ret =false;
                throwe;
            }
            finally
            {
                System.out.println("testEx1,finally; return value=" + ret);
                returnret;
            }
        }
        boolean testEx2() throws Exception
        {
            boolean ret = true;
            try
            {
                int b =12;
                int c;
                for(int i = 2; i >= -2; i--)
                {
                    c= b / i;
                    System.out.println("i="+ i);
                }
                returntrue;
            }
            catch (Exception e)
            {
                System.out.println("testEx2,catch exception");
                ret =false;
                throwe;
            }
            finally
            {
                System.out.println("testEx2,finally; return value=" + ret);
                returnret;
            }
        }
        public static void main(String[] args)
        {
            TestException testException1 =new TestException();
            try
            {
                testException1.testEx();
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
        }
    }


    你的答案是什么?是下面的答案吗?
    i=2
    i=1
    testEx2, catch exception
    testEx2, finally; return value=false
    testEx1, catch exception
    testEx1, finally; return value=false
    testEx, catch exception
    testEx, finally; return value=false


    如果你的答案真的如上面所说,那么你错啦。^_^,那就建议你仔细看一看这篇文章或者拿上面的代码按各种不同的情况修改、执行、测试,你会发现有很多事情不是原来想象中的那么简单的。
    现在公布正确答案:
    i=2
    i=1
    testEx2, catch exception
    testEx2, finally; return value=false
    testEx1, catch exception
    testEx1, finally; return value=false
    testEx, catch exception
    testEx, finally; return value=false

    2 基础知识

    2.1 相关概念
    例外是在程序运行过程中发生的异常事件,比如除0溢出、数组越界、文件找不到等,这些事件的发生将阻止程序的正常运行。为了加强程序的鲁棒性,程序设计时,必须考虑到可能发生的异常事件并做出相应的处理。C语言中,通过使用if语句来判断是否出现了例外,同时,调用函数通过被调用函数的返回值感知在被调用函数中产生的例外事件并进行处理。全程变量ErroNo常常用来反映一个异常事件的类型。但是,这种错误处理机制会导致不少问题。
    Java
    通过面向对象的方法来处理例外。在一个方法的运行过程中,如果发生了例外,则这个方法生成代表该例外的一个对象,并把它交给运行时系统,运行时系统寻找相应的代码来处理这一例外。我们把生成例外对象并把它提交给运行时系统的过程称为抛弃(throw)一个例外。运行时系统在方法的调用栈中查找,从生成例外的方法开始进行回朔,直到找到包含相应例外处理的方法为止,这一个过程称为捕获(catch)一个例外。
    2.2 Throwable
    类及其子类
     用面向对象的方法处理例外,就必须建立类的层次。类 Throwable位于这一类层次的最顶层,只有它的后代才可以做为一个例外被抛弃。图1表示了例外处理的类层次。
    从图中可以看出,类Throwable有两个直接子类:ErrorExceptionError类对象(如动态连接错误等),由Java虚拟机生成并抛弃(通常,Java程序不对这类例外进行处理);Exception类对象是Java程序处理或抛弃的对象。它有各种不同的子类分别对应于不同类型的例外。其中类RuntimeException代表运行时由Java虚拟机生成的例外,如算术运算例外ArithmeticException(由除0错等导致)、数组越界例外ArrayIndexOutOfBoundsException等;其它则为非运行时例外,如输入输出例外IOException等。Java编译器要求Java程序必须捕获或声明所有的非运行时例外,但对运行时例外可以不做处理。

    2.3  异常处理关键字
    Java
    的异常处理是通过5个关键字来实现的:trycatchthrowthrowsfinallyJB的在线帮助中对这几个关键字是这样解释的:
    Throws:  Lists the exceptions a method could throw.
    Throw:   Transfers control of the method to the exceptionhandler.
    Try
        Opening exception-handling statement.
    Catch
      Captures the exception.
    Finally
    Runs its code before terminating the program.
    2.3.1 try
    语句 
    try
    语句用大括号{}指定了一段代码,该段代码可能会抛弃一个或多个例外。
    2.3.2 catch
    语句 
    catch
    语句的参数类似于方法的声明,包括一个例外类型和一个例外对象。例外类型必须为Throwable类的子类,它指明了catch语句所处理的例外类型,例外对象则由运行时系统在try所指定的代码块中生成并被捕获,大括号中包含对象的处理,其中可以调用对象的方法。
    catch
    语句可以有多个,分别处理不同类的例外。Java运行时系统从上到下分别对每个catch语句处理的例外类型进行检测,直到找到类型相匹配的catch语句为止。这里,类型匹配指catch所处理的例外类型与生成的例外对象的类型完全一致或者是它的父类,因此,catch语句的排列顺序应该是从特殊到一般。
    也可以用一个catch语句处理多个例外类型,这时它的例外类型参数应该是这多个例外类型的父类,程序设计中要根据具体的情况来选择catch语句的例外处理类型。 
    2.3.3 finally
    语句 
    try
    所限定的代码中,当抛弃一个例外时,其后的代码不会被执行。通过finally语句可以指定一块代码。无论try所指定的程序块中抛弃或不抛弃例外,也无论catch语句的例外类型是否与所抛弃的例外的类型一致,finally所指定的代码都要被执行,它提供了统一的出口。通常在finally语句中可以进行资源的清除工作。如关闭打开的文件等。
    2.3.4 throws
    语句 
    throws
    总是出现在一个函数头中,用来标明该成员函数可能抛出的各种异常。对大多数Exception子类来说,Java编译器会强迫你声明在一个成员函数中抛出的异常的类型。如果异常的类型是ErrorRuntimeException或它们的子类,这个规则不起作用,因为这在程序的正常部分中是不期待出现的。如果你想明确地抛出一个RuntimeException,你必须用throws语句来声明它的类型。
    2.3.5 throw
    语句 
    throw
    总是出现在函数体中,用来抛出一个异常。程序会在throw语句后立即终止,它后面的语句执行不到,然后在包含它的所有try块中(可能在上层调用函数中)从里向外寻找含有与其匹配的catch子句的try块。

    3 关键字及其中语句流程详解

    3.1 try的嵌套
    你可以在一个成员函数调用的外面写一个try语句,在这个成员函数内部,写另一个try语句保护其他代码。每当遇到一个try语句,异常的框架就放到堆栈上面,直到所有的try语句都完成。如果下一级的try语句没有对某种异常进行处理,堆栈就会展开,直到遇到有处理这种异常的try语句。下面是一个try语句嵌套的例子。

    class MultiNest {
        static void procedure() {
            try {
                int a =0;
                int b =42/a;
            } catch(java.lang.ArithmeticExceptione) {
                System.out.println("inprocedure, catch ArithmeticException: " + e);
            }
        }
        public static void main(String args[]) {
            try {
                procedure();
            } catch(java.lang. Exception e){
                System.out.println("inmain, catch Exception: " + e);
            }
        }
    }


    这个例子执行的结果为:
    in procedure, catch ArithmeticException: java.lang.ArithmeticException: / byzero
    成员函数procedure里有自己的try/catch控制,所以main不用去处理ArrayIndexOutOfBoundsException;当然如果如同最开始我们做测试的例子一样,在procedurecatch到异常时使用throwe;语句将异常抛出,那么main当然还是能够捕捉并处理这个procedure抛出来的异常。例如在procedure函数的catch中的System.out语句后面增加throwe;语句之后,执行结果就变为:
    in procedure, catch ArithmeticException: java.lang.ArithmeticException: / byzero
    in main, catch Exception: java.lang.ArithmeticException: / by zero

    3.2 try-catch程序块的执行流程以及执行结果
    相对于try-catch-finally程序块而言,try-catch的执行流程以及执行结果还是比较简单的。
    首先执行的是try语句块中的语句,这时可能会有以下三种情况:
        1
    .如果try块中所有语句正常执行完毕,那么就不会有其他的动做被执行,整个try-catch程序块正常完成。
        2
    .如果try语句块在执行过程中碰到异常V,这时又分为两种情况进行处理:
    -->
    如果异常V能够被与try相应的catchcatch到,那么第一个catch到这个异常的catch块(也是离try最近的一个与异常V匹配的catch块)将被执行;如果catch块执行正常,那么try-catch程序块的结果就是正常完成;如果该catch块由于原因R突然中止,那么try-catch程序块的结果就是由于原因R突然中止(completesabruptly
    -->
    如果异常V没有catch块与之匹配,那么这个try-catch程序块的结果就是由于抛出异常V而突然中止(completesabruptly
        3
    如果try由于其他原因R突然中止(completesabruptly),那么这个try-catch程序块的结果就是由于原因R突然中止(completesabruptly

    3.3try-catch-finally程序块的执行流程以及执行结果
    try-catch-finally
    程序块的执行流程以及执行结果比较复杂。
    首先执行的是try语句块中的语句,这时可能会有以下三种情况:
    1
    .如果try块中所有语句正常执行完毕,那么finally块的居于就会被执行,这时分为以下两种情况:
    -->
    如果finally块执行顺利,那么整个try-catch-finally程序块正常完成。
    -->
    如果finally块由于原因R突然中止,那么try-catch-finally程序块的结局是由于原因R突然中止(completes abruptly
    2
    .如果try语句块在执行过程中碰到异常V,这时又分为两种情况进行处理:
    -->
    如果异常V能够被与try相应的catchcatch到,那么第一个catch到这个异常的catch块(也是离try最近的一个与异常V匹配的catch块)将被执行;这时就会有两种执行结果:
    -->
    如果catch块执行正常,那么finally块将会被执行,这时分为两种情况:
    -->
    如果finally块执行顺利,那么整个try-catch-finally程序块正常完成。
    -->
    如果finally块由于原因R突然中止,那么try-catch-finally程序块的结局是由于原因R突然中止(completes abruptly
    -->
    如果catch块由于原因R突然中止,那么finally模块将被执行,分为两种情况:
    -->
    如果如果finally块执行顺利,那么整个try-catch-finally程序块的结局是由于原因R突然中止(completes abruptly
    -->
    如果finally块由于原因S突然中止,那么整个try-catch-finally程序块的结局是由于原因S突然中止(completes abruptly,原因R将被抛弃。
    (注意,这里就正好和我们的例子相符合,虽然我们在testEx2中使用throw e抛出了异常,但是由于testEx2中有finally块,而finally块的执行结果是complete abruptly的(别小看这个用得最多的return,它也是一种导致complete abruptly的原因之一啊——后文中有关于导致complete abruptly的原因分析),所以整个try-catch-finally程序块的结果是“complete abruptly”,所以在testEx1中调用testEx2时是捕捉不到testEx1中抛出的那个异常的,而只能将finally中的return结果获取到。
    如果在你的代码中期望通过捕捉被调用的下级函数的异常来给定返回值,那么一定要注意你所调用的下级函数中的finally语句,它有可能会使你throw出来的异常并不能真正被上级调用函数可见的。当然这种情况是可以避免的,以testEx2为例:如果你一定要使用finally而且又要将catchthrowetestEx1中被捕获到,那么你去掉testEx2中的finally中的return就可以了。
    这个事情已经在OMC2.0MIB中出现过啦:服务器的异常不能完全被反馈到客户端。)
    -->
    如果异常V没有catch块与之匹配,那么finally模块将被执行,分为两种情况:
    -->
    如果finally块执行顺利,那么整个try-catch-finally程序块的结局就是由于抛出异常V而突然中止(completes abruptly
    -->
    如果finally块由于原因S突然中止,那么整个try-catch-finally程序块的结局是由于原因S突然中止(completes abruptly,异常V将被抛弃。
    3
    .如果try由于其他原因R突然中止(completesabruptly),那么finally块被执行,分为两种情况:
    -->
    如果finally块执行顺利,那么整个try-catch-finally程序块的结局是由于原因R突然中止(completes abruptly
    -->
    如果finally块由于原因S突然中止,那么整个try-catch-finally程序块的结局是由于原因S突然中止(completes abruptly,原因R将被抛弃。
    3.4 try-catch-finally
    程序块中的return
    从上面的try-catch-finally程序块的执行流程以及执行结果一节中可以看出无论trycatch中发生了什么情况,finally都是会被执行的,那么写在try或者catch中的return语句也就不会真正的从该函数中跳出了,它的作用在这种情况下就变成了将控制权(语句流程)转到finally块中;这种情况下一定要注意返回值的处理。
    例如,在try或者catchreturnfalse了,而在finally中又return true,那么这种情况下不要期待你的try或者catch中的return false的返回值false被上级调用函数获取到,上级调用函数能够获取到的只是finally中的返回值,因为try或者catch中的return语句只是转移控制权的作用。
    3.5
    如何抛出异常
    如果你知道你写的某个函数有可能抛出异常,而你又不想在这个函数中对异常进行处理,只是想把它抛出去让调用这个函数的上级调用函数进行处理,那么有两种方式可供选择:
    第一种方式:直接在函数头中throws SomeException,函数体中不需要try/catch。比如将最开始的例子中的testEx2改为下面的方式,那么testEx1就能捕捉到testEx2抛出的异常了。
       

     boolean testEx2() throws Exception{
            boolean ret = true;
            int b=12;
            int c;
            for (int i=2;i>=-2;i--){
                c=b/i;
                System.out.println("i="+i);
            }
            return true;   
    }


    第二种方式:使用try/catch,在catch中进行一定的处理之后(如果有必要的话)抛出某种异常。例如上面的testEx2改为下面的方式,testEx1也能捕获到它抛出的异常:
      
      boolean testEx2() throws Exception{
            boolean ret = true;
            try{
                intb=12;
                int c;
                for(int i=2;i>=-2;i--){
                    c=b/i;
                    System.out.println("i="+i);
                }
                returntrue;
            }catch (Exception e){
                System.out.println("testEx2,catch exception");
                Throwe;
            }
        }


    第三种方法:使用try/catch/finally,在catch中进行一定的处理之后(如果有必要的话)抛出某种异常。例如上面的testEx2改为下面的方式,testEx1也能捕获到它抛出的异常:
     
       boolean testEx2() throws Exception{
            boolean ret = true;
            try{
                intb=12;
                int c;
                for(int i=2;i>=-2;i--){
                    c=b/i;
                    System.out.println("i="+i);
                    thrownew Exception("aaa");
                }
                returntrue;
            }catch(java.lang.ArithmeticException e){
                System.out.println("testEx2,catch exception");
                ret =false;
                thrownew Exception("aaa");
            }finally{
                System.out.println("testEx2,finally; return value="+ret);
            }
        }


    4  关于abrupt completion
    前面提到了complete abruptly(暂且理解为突然中止或者异常结束吧),它主要包含了两种大的情形:abrupt completion of expressions and statements,下面就分两种情况进行解释。
    4.1 Normal and Abrupt Completion of Evaluation
    每一个表达式(expression)都有一种使得其包含的计算得以一步步进行的正常模式,如果每一步计算都被执行且没有异常抛出,那么就称这个表达式正常结束(completenormally;如果这个表达式的计算抛出了异常,就称为异常结束(completeabruptly。异常结束通常有一个相关联的原因(associated reason),通常也就是抛出一个异常V
    与表达式、操作符相关的运行期异常有:
    -->A class instance creation expression, array creation expression , orstring concatenation operatior expression throws an OutOfMemoryError if thereis insufficient memory available.
    -->An array creation expression throws a NegativeArraySizeException if thevalue of any dimension expression is less than zero.
    -->A field access throws a NullPointerException if the value of the objectreference  expression is null.
    -->A method invocation expression that invokes an instance method throws aNullPointerException if the target reference is null.
    -->An array access throws a NullPointerException if the value of the arrayreference  expression is null.
    -->An array access throws an ArrayIndexOutOfBoundsException if the value ofthe array index expression is negative or greater than or equal to the lengthof the array.
    -->A cast throws a ClassCastException if a cast is found to be impermissibleat run time.
    -->An integer division or integer remainder operator throws anArithmeticException if the value of the right-hand operand expression is zero.
    -->An assignment to an array component of reference type throws anArrayStoreException when the value to be assigned is not compatible with thecomponent type of the array.
    4.2 Normal and Abrupt Completion of Statements
    正常情况我们就不多说了,在这里主要是列出了abrupt completion的几种情况:
    -->break, continue, and return
    语句将导致控制权的转换,从而使得statements不能正常地、完整地执行。
    -->
    某些表达式的计算也可能从java虚拟机抛出异常,这些表达式在上一小节中已经总结过了;一个显式的的throw语句也将导致异常的抛出。抛出异常也是导致控制权的转换的原因(或者说是阻止statement正常结束的原因)。
    如果上述事件发生了,那么这些statement就有可能使得其正常情况下应该都执行的语句不能完全被执行到,那么这些statement也就是被称为是complete abruptly.
    导致abrupt completion的几种原因:
    -->A break with no label
    -->A break with a given label
    -->A continue with no label
    -->A continue with a given label
    -->A return with no value
    -->A return with a given value A
    -->throw with a given value, including exceptions thrown by the Java virtualmachine
    5
    关于我们的编程的一点建议
    弄清楚try-catch-finally的执行情况后我们才能正确使用它。
    如果我们使用的是try-catch-finally语句块,而我们又需要保证有异常时能够抛出异常,那么在finally语句中就不要使用return语句了(finally语句块的最重要的作用应该是释放申请的资源),因为finally中的return语句会导致我们的throw e被抛弃,在这个try-catch-finally的外面将只能看到finally中的返回值(除非在finally中抛出异常)。(我们需要记住:不仅throw语句是abruptcompletion的原因,returnbreakcontinue等这些看起来很正常的语句也是导致abrupt completion的原因。)

     

    展开全文
  • C++中catch(…)如何使用

    千次阅读 2013-08-30 10:40:40
    上一篇文章中详细讲了讲C++异常处理模型的trycatch使用语法,其中catch关键字是用来定义catch block的,它后面带一个参数,用来与异常对象的数据类型进行匹配。注意catch关键字只能定义一个参数,因此每个catch ...
    上一篇文章中详细讲了讲C++异常处理模型的trycatch使用语法,其中catch关键字是用来定义catch block的,它后面带一个参数,用来与异常对象的数据类型进行匹配。注意catch关键字只能定义一个参数,因此每个catch block只能是一种数据类型的异常对象的错误处理模块。如果要想使一个catch block能抓获多种数据类型的异常对象的话,怎么办?C++标准中定义了一种特殊的catch用法,那就是” catch(…)”。
    

    感性认识

    1、catch(…)到底是一个什么样的东东,先来个感性认识吧!看例子先:

    int main()
    {
    try
    {
    cout << "在 try block 中, 准备抛出一个异常." << endl;
    //这里抛出一个异常(其中异常对象的数据类型是int,值为1)
    throw 1;
    }
    //catch( int& value )
    //注意这里catch语句
    catch( …)
    {
    cout << "在 catch(…) block 中, 抛出的int类型的异常对象被处理" << endl;
    }
    }

      2、哈哈!int类型的异常被catch(…)抓获了,再来另一个例子:

    int main()
    {
    try
    {
    cout << "在 try block 中, 准备抛出一个异常." << endl;
    //这里抛出一个异常(其中异常对象的数据类型是double,值为0.5)
    throw 0.5;
    }
    //catch( double& value )
    //注意这里catch语句
    catch( …)
    {
    cout << "在 catch(…) block 中, double类型的异常对象也被处理" << endl;
    }
    }

       3、同样,double类型的异常对象也被catch(…)块抓获了。是的,catch(..)能匹配成功所有的数据类型的异常对象,包括C++语言提 供所有的原生数据类型的异常对象,如int、double,还有char*、int*这样的指针类型,另外还有数组类型的异常对象。同时也包括所有自定义 的抽象数据类型。例程如下:

    int main()
    {
    try
    {
    cout << "在 try block 中, 准备抛出一个异常." << endl;
    //这里抛出一个异常(其中异常对象的数据类型是char*)
    char* p=0;
    throw p;
    }
    //catch( char* value )
    //注意这里catch语句
    catch( …)
    {
    cout << "在 catch(…) block 中, char*类型的异常对象也被处理" << endl;
    }
    }


    int main()
    {
    try
    {
    cout << "在 try block 中, 准备抛出一个异常." << endl;
    //这里抛出一个异常(其中异常对象的数据类型是int[])
    int a[4];
    throw a;
    }
    //catch( int value[] )
    //注意这里catch语句
    catch( …)
    {
    cout << "在 catch(…) block 中, int[]类型的异常对象也被处理" << endl;
    }
    }

      4、对于抽象数据类型的异常对象。catch(…)同样有效,例程如下:

    class MyException
    {
    public:
    protected:
    int code;
    };

    int main()
    {
    try
    {
    cout << "在 try block 中, 准备抛出一个异常." << endl;
    //这里抛出一个异常(其中异常对象的数据类型是MyException)
    throw MyException();
    }
    //catch(MyException& value )
    //注意这里catch语句
    catch( …)
    {
    cout << "在catch(…) block中, MyException类型的异常对象被处理" << endl;
    }
    }
    对catch(…)有点迷糊?
    1、究竟对catch(…)有什么迷糊呢?还是看例子先吧!
    void main()
    {
    int* p = 0;

    try
    {
    // 注意:下面这条语句虽然不是throw语句,但它在执行时会导致系统
    // 出现一个存储保护错误的异常(access violation exception)
    *p = 13; // causes an access violation exception;
    }
    catch(...)
    {
    //catch(…)能抓获住上面的access violation exception异常吗?
    cout << "在catch(…) block中" << endl;
    }
    }

      请问上面的程序运行时会出现什么结果吗?catch(…)能抓获住系统中出现的access violation exception异常吗?朋友们!和我们的主人公阿愚一样,自己动手去测试一把!
    结果又如何呢?实际上它有两种不同的运行结果,在window2000系统下用VC来测试运行这个小程序时,发现程序能输出"在catch(…) block中"的语句在屏幕上,也即catch(…) 能成功抓获住系统中出现的access violation exception异常,很厉害吧!但如果这个同样的程序在linux下用gcc编译后运行时,程序将会出现崩溃,并在屏幕上输出”segment fault”的错误信息。

    主人公阿愚有点急了,也开始有点迷糊了,为什么?为什么?为什么同样一个程序在两种不同的系统上有不同的表现呢?其原因就是:对于这种由于硬件或操作 系统出现的系统异常(例如说被零除、内存存储控制异常、页错误等等)时,window2000系统有一个叫做结构化异常处理(Structured Exception Handling,SEH)的机制,这个东东太厉害了,它能和VC中的C++异常处理模型很好的结合上(实际上VC实现的C++异常处理模型很大程度上建 立在SEH机制之上的,或者说它是SEH的扩展,后面文章中会详细阐述并分析这个久富盛名的SEH,看看catch(…)是如何神奇接管住这种系统异常出 现后的程序控制流的,不过这都是后话)。而在linux系统下,系统异常是由信号处理编程方法来控制的(信号处理编程,signal processing progamming。在介绍unix和linux下如何编程的书籍中,都会有对信号处理编程详细的介绍,当然执著的主人公阿愚肯定对它也不会放过,会深 入到unix沿袭下来的信号处理编程内部的实现机制,并尝试完善改进它,使它也能够较好地和C++异常处理模型结合上)。

    那么C++标准中对于这种同一个程序有不同的运行结果有何解释呢?这里需要注意的是,window2000系统下catch(…)能捕获住系统异常, 这完全是它自己的扩展。在C++标准中并没有要求到这一点,它只规定catch(…)必须能捕获程序中所有通过throw语句抛出的异常。因此上面的这个 程序在linux系统下的运行结果也完全是符合C++标准的。虽然大家也必须承认window2000系统下对C++异常处理模型的这种扩展确实是一个很 不错的完善,极大得提高了程序的安全性。

    为什么要用catch(…)这个东东?

    程序员朋友们也许会说,这还有问吗?这篇文章的一开始不就讲到了吗?catch(…)能够捕获多种数据类型的异常对象,所以它提供给程序员一种对异常 对象更好的控制手段,使开发的软件系统有很好的可靠性。因此一个比较有经验的程序员通常会这样组织编写它的代码模块,如下:

    void Func()
    {
    try
    {
    // 这里的程序代码完成真正复杂的计算工作,这些代码在执行过程中
    // 有可能抛出DataType1、DataType2和DataType3类型的异常对象。
    }
    catch(DataType1& d1)
    {
    }
    catch(DataType2& d2)
    {
    }
    catch(DataType3& d3)
    {
    }
    // 注意上面try block中可能抛出的DataType1、DataType2和DataType3三
    // 种类型的异常对象在前面都已经有对应的catch block来处理。但为什么
    // 还要在最后再定义一个catch(…) block呢?这就是为了有更好的安全性和
    // 可靠性,避免上面的try block抛出了其它未考虑到的异常对象时导致的程
    // 序出现意外崩溃的严重后果,而且这在用VC开发的系统上更特别有效,因
    // 为catch(…)能捕获系统出现的异常,而系统异常往往令程序员头痛了,现
    // 在系统一般都比较复杂,而且由很多人共同开发,一不小心就会导致一个
    // 指针变量指向了其它非法区域,结果意外灾难不幸发生了。catch(…)为这种
    // 潜在的隐患提供了一种有效的补救措施。
    catch(…)
    {
    }
    }

    还有,特别是VC程序员为了使开发的系统有更好的可靠性,往往在应用程序的入口函数中(如MFC框架的开发环境下 CXXXApp::InitInstance())和工作线程的入口函数中加上一个顶层的trycatch块,并且使用catch(…)来捕获一切所有的 异常,如下:

    BOOL CXXXApp::InitInstance()
    {
    if (!AfxSocketInit())
    {
    AfxMessageBox(IDP_SOCKETS_INIT_FAILED);
    return FALSE;
    }

    AfxEnableControlContainer();

    // Standard initialization
    // If you are not using these features and wish to reduce the size
    // of your final executable, you should remove from the following
    // the specific initialization routines you do not need.

    #ifdef _AFXDLL
    Enable3dControls(); // Call this when using MFC in a shared DLL
    #else
    Enable3dControlsStatic(); // Call this when linking to MFC statically
    #endif


    // 注意这里有一个顶层的trycatch块,并且使用catch(…)来捕获一切所有的异常
    try
    {
    CXXXDlg dlg;
    m_pMainWnd = &dlg;
    int nResponse = dlg.DoModal();
    if (nResponse == IDOK)
    {
    // TODO: Place code here to handle when the dialog is
    // dismissed with OK
    }
    else if (nResponse == IDCANCEL)
    {
    // TODO: Place code here to handle when the dialog is
    // dismissed with Cancel
    }
    }
    catch(…)
    {
    // dump出系统的一些重要信息,并通知管理员查找出现意外异常的原因。
    // 同时想办法恢复系统,例如说重新启动应用程序等
    }

    // Since the dialog has been closed, return FALSE so that we exit the
    // application, rather than start the application's message pump.
    return FALSE;
    }

       通过上面的例程和分析可以得出,由于catch(…)能够捕获所有数据类型的异常对象,所以在恰当的地方使用catch(…)确实可以使软件系统有着更 好的可靠性。这确实是大家使用catch(…)这个东东最好的理由。但不要误会的是,在C++异常处理模型中,不只有catch(…)方法能够捕获几乎所 有类型的异常对象(也许有其它更好的方法,在下一篇文章中主人公阿愚带大家一同去探讨一下),可C++标准中为什么会想到定义这样一个catch(…) 呢?有过java或C#编程开发经验的程序员会发现,在它们的异常处理模型中,并没有这样类似的一种语法,可这里不得不再次强调的是,java中的异常处 理模型是C++中的异常处理模型的完善改进版,可它反而没有了catch(…),为何呢?还是先去看看下一章吧,“C++的异常处理和面向对象的紧密关系 ”。也许大家能找到一个似乎合理的原因。

    展开全文
  • .catch与then

    千次阅读 2019-01-04 17:39:00
    .catch的作用是捕捉前一个函数的错误

    .catch的作用是捕捉前一个函数的错误

    展开全文
  • 如何使用try{}catch(){} /*当里面有错误时不抛出错误,而且运行catch里面的语句,try里面错误语句的后续代码不再运行,但是不影响后续代码运行*/ try{ console.log('a'); console.log(b); console.log('...
  • 浅谈Java中try catch 的用法

    万次阅读 多人点赞 2018-11-10 15:37:21
    我们编译运行程序出错的时候,编译器就会抛出异常。抛出异常要比终止程序灵活许多,这是因为 的Java提供了一个“捕获”异常的的处理器(处理器)对异常情况进行处理。 如果没有提供处理器机制,程序就会终止,并在...
  • package test.s; public class yichang { public static void main(String[] args) throws Exception{ try{ double a=aa(); System.out.println(a);... }catch(Exception e){ e.printStackTrace(); }
  • 1.Promise.prototype.then()方法Promise 实例具有then方法,也就是说,then方法是定义在原型对象Promise.prototype上的。它的作用是为 Promise 实例添加状态改变时的回调函数。then方法的第一个参数是resolved状态的...
  • @Test public void excp() { try { int i = 1/0;... }catch (Exception e) { e.printStackTrace(); // TODO: handle exception } } 结果:直接抛出异常不好try内的输出不会继续执行下去 ...
  • try catch 语句好不好?

    千次阅读 热门讨论 2016-06-12 23:24:38
    try catch 语句好不好? 一句话解释:    try catch机制可以非常好。觉得try catch 不是很好的,可能是还没有发现她的好! 详细解释: 1.程序要健壮,必须要设计报错机制。 最古老,也是最常见的,比如:...
  • C++中try/catch/throw的使用

    万次阅读 2017-03-25 19:12:46
    C++异常处理涉及到三个关键字:try、catch、throw。 在C++语言中,异常处理包括: (1)、throw表达式:异常检测部分使用throw表达式来表示它遇到了无法处理的问题,throw引发了异常。throw表达...
  • PHP异常(try catch

    万次阅读 2019-06-24 23:29:34
    <?php /**************************************************** * php处理异常 * try中不主动throw,会先出现PHP的系统错误 ****************************************************/ ...
  • catch2:一个好用的C++单元测试框架

    千次阅读 2019-02-24 23:17:08
    文章目录为什么需要catch简单易用命令行选项SectionsBDD-styleAssertion MacrosFloating point comparisonsExceptionsMatchersString matchersVector matchersFloating point matchersCustom matchers 最近发现一个...
  • try catch throw用法

    千次阅读 2013-04-03 10:00:10
    要防止因为异常产生的内存泄漏,可以使用智能指针,也可以用 __try { } __finally ...《Windows核心编程》一书第23~25章是很好的参考...try,catch,throw: try包含你要防护的代码,称为防护块. 防护块如果出现异
  • try catch的作用

    千次阅读 多人点赞 2018-03-29 11:25:16
    try catch的作用:当程序发生错误时,能够保证程序继续执行下去。用一个简单例子说明:1:无try catchpublic static void main(String[] args) { int i; i = 2/0; System.out.println(i); System.out.println...
  • Try Catch block

    千次阅读 2013-11-16 00:52:18
    选择异常处理的编程方法的具体原因如下: ... catch可以分层嵌套,所以它提供了一种方法使得程序的控制流可以安全的跳转到上层(或者上上层)的错误处理模块中去。(不同于return语句,异常处理的控制流
  • JavaScript中try{}catch{}finally的使用

    万次阅读 2019-07-28 13:08:05
    try{}catch{}finally{}的使用 try{}catch{}finally{} 语句一般是用来将有可能引发错误的代码(比如异步请求)放在try语句块中,并且对应一个响应,然后有异常被抛出到catch中。 语法: try { //有可能引发错误的...
  • Try catch如何使用

    千次阅读 2019-05-16 18:43:36
    try catch适用场合: 一、兼容性 浏览器的兼容性是程序员很头痛的事儿,往往一些出错会让我们查找许久,在使用try catch能更好的解决兼容性出错的问题:由于不同浏览器报错提示也不尽相同,通过使用try catch捕获的...
  • try、catch、finally用法

    万次阅读 2013-08-20 11:17:02
    try { //执行的代码,其中可能有异常。一旦发现异常,则立即跳到catch执行。...//不管什么情况都会执行,包括try catch 里面用了return ,可以理解为只要执行了try或者catch,就一定会执行 finally }
  • 文章目录1、异常1.1 异常概念1.2 异常体系1.3 异常分类1.4 异常的产生过程解析2、 异常的处理2.1 抛出异常throw2.2 Objects非空判断2.3 声明异常throws2.4 捕获异常try…catch2.4 finally 代码块2.5 异常注意事项3...

空空如也

1 2 3 4 5 ... 20
收藏数 2,201,090
精华内容 880,436
关键字:

catch