Re: catch (...)

From:

"Alf P. Steinbach" <alfps@start.no>

Newsgroups:

comp.lang.c++

Date:

Tue, 25 Apr 2006 19:29:24 +0200

Message-ID:

<4b74jnFv5jqsU1@individual.net>

* mlimber:

Alf P. Steinbach wrote:

* Phlip:

Cy Edmunds wrote:

On the contrary, there is a specific exception caught in a catch-all.

Try

  #include <cstddef>
  #include <stdexcept>
  #include <iostream>
  #include <ostream>

  int main()
  {
      try
      {
          throw std::runtime_error( "Indeed" );
      }
      catch( ... )
      {
          try
          {
              throw;
          }
          catch( std::exception const& x )
          {
              std::cerr << "!" << x.what() << std::endl;
          }
          catch( ... )
          {
              std::cerr << "!Unknown exception" << std::endl;
          }
          return EXIT_FAILURE;
      }
  }

Modulo typos, of course; also, won't work with older compilers like VC6.

The inner try-catch can be moved to a separate function.

Right! This tip really helped me with a project I'm working on. Thanks!

That tip is a super-complex way to simply say this:

       try
       {
           throw std::runtime_error( "Indeed" );
       }
       catch( std::exception const& x )
       {
           std::cerr << "!" << x.what() << std::endl;
           return EXIT_FAILURE;
       }
       catch( ... )
       {
           std::cerr << "!Unknown exception" << std::endl;
           return EXIT_FAILURE;
        }

No.

Mostly, the technique is applicable when you have several different
exception types originating from various third-part libraries.

Placing a multiple try-catch like the above in every function really
isn't an option, and using macros to generate such beasties isn't a very
clean solution. A separate exception conversion function is then a
relatively clean way to deal with the exceptions. All it requires is a
catch-all in each function that deals directly with lib functions.

I agree that using a conversion function such as this is cleaner in
some cases, but logically there is no difference between yours and
Phlip's code -- they both can catch the desired exception types and
give up on others.

Feel free to use assembly language.

Or manually inline expanded code.

After all any C++ program can be expressed (a bit more verbosely) in
assembly language, and actually assembly language is a bit more powerful
in what can be done -- it's the logical choice! :-o

In the catch-all block of your handler, you still
don't have any information on the "other" exception (except that it is
not one of the explicitly caught types), which is presumably the same
situation the OP is in to begin with.

Only the OP can clarify whether this technique is useful to him or her.

This wasn't written in response to the OP.

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?