Re: Nested exception handling

From:

"Doug Harrison [MVP]" <dsh@mvps.org>

Newsgroups:

microsoft.public.vc.language

Date:

Mon, 01 Oct 2007 23:00:58 -0500

Message-ID:

<62g3g3t9vklfb4b8t2f9efdif1h2jspa17@4ax.com>

On Mon, 1 Oct 2007 20:30:01 -0700, Andrew
<Andrew@discussions.microsoft.com> wrote:

I am getting an internal compiler error C1001 when I use nested try blocks in
MS C++ 6.0. An example follows. The implementation of the method Change
causes the problem. Is this a compiler bug ? I can't find any syntax error.

#include <stdlib.h>

class ListInteger
{
    public:
        ListInteger(); // simple constructor
        ListInteger(int length); // constructor
        ListInteger(const ListInteger & rhs); // copy constructor (deep)
        ListInteger operator=(const ListInteger & rhs); // assignment (deep
copy)
        ~ListInteger(); // destructor
        int GetLength() const;
        int GetInteger(int k) const;
        void SetInteger(int k,int entry);
        static void Change(ListInteger & X);
        static int * intvec(int length);
        static void del_intvec(int * q,int length);
   private:
        int * itsInteger; // array of integers indexed from zero
        int itsLength; // length of list
};

// produces fatal error C1001: INTERNAL COMPILER ERROR
void ListInteger::Change(ListInteger & L)
{
   try
   {
       ListInteger save = L;
       try
       {
           //...
       }
       catch (...)
       {
           try
           {
               L = save;
               //...
           }
           catch (...)
           {
               try
               {
                   L = save;
                   //...
                }
               catch (...)
               {
                   //...
                   throw;
                }
           }
       }
       save = L;
       try
       {
            //...
        }
        catch (...)
        {
             try
             {
                  L = save;
                  //...
              }
             catch (...)
             {
                  try
                  {
                      //...
                   }
                  catch (...)
                  {
                       //...
                       throw;
                  }
              }
          }
      }
      catch (...)
      {
           //...
           throw;
      }
}

VC 2005 doesn't have any problem with it. That said, no matter what the
elided code looks like, it's very hard to imagine this can be a good use of
exceptions. It appears you're using exceptions as an alternative to return
codes on a 1:1 basis, but a major advantage of exceptions is that they
allow you to separate program logic from error handling. Well-written
programs contain few try/catch blocks; they instead rely on destructors of
local objects to perform whatever clean-up is necessary, and most functions
don't contain a try/catch block.

--
Doug Harrison
Visual C++ MVP