|< C & C++ Exception Handling 1 | Main | C & C++ Typecasting 1 >|Site Index |Download |

MODULE 21a

C AND C++ EXCEPTION HANDLING 2

 In the worst case, there must be an emergency exit!

void test(int somecode) throw (bad_code, no_auth);

void (*PtrFunct)(double) throw(string, double); 

// more restrictive than PtrFunct:

void One(double) throw (string); 

// as restrictive as PtrFunct:

void Two(double) throw (string, double); 

// less restrictive than PtrFunct:

void Three(double) throw (string, double, bool); 

PtrFunct = One; 	// OK

PtrFunct = Two; 	// OK

class Test

{

    public: 

    	// may throw any exception

    	int One(char *VarPtr);

    	// doesn't throw any exception

    	int Two(double *VarPtr1) throw();

};

• Exception specifications are enforced at the runtime. When a function violates its exception specification,unexpected() function is called.

• Theunexpected() function invokes a user-defined function that was previously registered by calling set_unexpected().

• If no function was registered with set_unexpected(),unexpected() calls terminate() which aborts the program unconditionally.

• The following table summarizes C++'s implementation of exception specifications:

• The following are examples of the exception specification implementation.

• If exception handling is used in an application, there must be one or more functions that handle thrown exceptions.

• Any functions called between the one that throws an exception and the one that handles the exception must be capable of throwing the exception.  However, explicit exception specifications are not allowed on C functions.

// exception specification

#include <iostream>

using namespace std;

// handler function

void handler()

{cout<<"In the handler()\n";}

// int throw...

void Funct1(void) throw(int)

{

       static int x = 1;

       cout<<"Funct1() call #"<<x++<<endl;

       cout<<"About to throw 1\n";

       if (1)

       throw 1;

}

// empty throw...

void Funct5(void) throw()

{

       try

       {Funct1();}

       catch(...)

       {handler();}

}

// invalid, doesn't handle the int exception thrown from Funct1()

// void Funct3(void) throw()  

// {

//   Funct1();

// }

void Funct2(void)

{

       try

           {Funct1();}

       catch(int)

           {handler();}

}

// assume extern "C" functions don't throw exceptions

extern "C" void Funct4(void);

void Funct4(void)

    {Funct1();}

int main()

{

       Funct2();

       try

           {Funct4();}

       catch(...)

           {cout<<"Caught exception from Funct4()\n";}

       Funct5();

       return 0;

}

Output:

21.9  Exception Handling Overhead

• The extra overhead associated with the C++ exception handling mechanism may increase the size of executable files and slow your program execution.

• So, exceptions should be used only in truly exceptional situations. Exception handlers should not be used to redirect the program's normal flow of control.

• For example, an exception should not be thrown in cases of potential logic or user input errors, such as the overflow of an array boundary. In these cases, simply returning an error code by using for example, the conditional if statement may be simpler and more concise.

21.10  Standard Exceptions

• The C++ exception class serves as the base class for all exceptions thrown by certain expressions and by the Standard C++ Library.

• Logical and run time errors are defined in Standard C++ <stdexcept> header file and this <stdexcept> is a derived class from the exception class where the Standard C++ header file is<exception>.

• Do not confuse with the exception class and <exception> header file, they refer to different thing here.  Header is denoted by the angled bracket < >. Exception class definition is shown below:

class exception

{

       public:

       exception( ) throw( );

       exception(constexception& right) throw( );

       exception& operator=(const exception& right) throw( );

       virtual ~exception( ) throw( );

       virtual const char *what( ) const throw( );

};

// standard exceptions program example

#include <iostream>

#include<exception>

#include <typeinfo>

using namespace std;

class Test1

{    virtual Funct() { };    };

int main ()

{

     try {

                Test1 * var = NULL;

                typeid (*var);

            }

catch (std::exception& typevar)

{    cout<<"Exception: "<<typevar.what()<<endl;    }

     return 0;

}

Output:

• Another code snippet example:

class out_of_range : public logic_error 

{

    public:

     out_of_range(const string& message);

};

• The value returned by what is a copy of message.

• A program example:

// out_of_range example

#include <string>

#include <iostream>

using namespace std;

int main( )

{

       try

       {

              string strg1("Test");

              string strg2("ing");

              strg1.append(strg2, 4, 2);

              cout<<strg1<<endl;

       }

       catch (exception &e)

       {

              cerr<<"Caught: "<<e.what()<<endl;

             cerr<<"Type: "<<typeid(e).name()<<endl;

       };

       return 0;

}

Output

• Other<exception> header members are listed in the following tables.

• Some simple program examples.

// bad_cast

// need to enable the Run-Time Type Info,

// rtti of your compiler.  You will learn

//typecasting in another Module…

#include <typeinfo>

#include <iostream>

usingnamespace std;

class Myshape

{

     public:

    virtual void myvirtualfunc() const {}

};

class mytriangle: public Myshape

{

     public:

    virtual void myvirtualfunc() const

     {   };

};

int main()

{

   Myshape Myshape_instance;

   Myshape &ref_Myshape = Myshape_instance;

  try {

           // try the run time typecasting, dynamic_cast

            mytriangle &ref_mytriangle = dynamic_cast<mytriangle&>(ref_Myshape);

   }

  catch (bad_cast) {

       cout<<"Can't do the dynamic_cast lor!!!"<<endl;

      cout<<"Caught: bad_cast exception. Myshape is not mytriangle.\n";

   }

  return 0;

}

Output:

// bad_alloc, first version, when the allocation is OK

#include <new>

#include <iostream>

usingnamespace std;

int main()

{

  char* ptr;

  unsigned longint Test = sizeof(size_t(0)/3);

   cout<<"The size of variable Test = "<<Test<<endl;

  try

   {

       // try some allocation...

       // size of an array must not exceed certain bytes

       ptr = new char[size_t(0)/3]

       delete[ ] ptr;

   }

  catch(bad_alloc &thebadallocation)

   {

      cout<<thebadallocation.what()<<endl;

   };

  return 0;

 }

Output:

• Let negate/inverse the array size, change the following

sizeof(size_t(0)/3)

• To the following code.

sizeof(~size_t(0)/3)

• Re-compile and re-run the program, the following output should be expected.

// set_unexpected

#include <exception>

#include <iostream>

usingnamespace std;

void myfunction()

{

   cout<<"Testing myfunction()."<<endl;

  //terminate() handler

   terminate();

}

int main( )

{

   unexpected_handler oldHandler = set_unexpected(myfunction);

  // unexpected() function call

   unexpected();

   return 0;

}

Output:

• Click the Abort button.

• The following example shows the typeid operator throwing a bad_typeid exception.

// bad_typeid

#include <typeinfo>

#include <iostream>

usingnamespace std;

class Test

{

    public:

    // object for a class needs vtable for the rtti...

    Test();

    virtual ~Test();

 };

int main()

{

     Test *ptrvar = NULL;

    try {

             // the error condition

             cout<<typeid(*ptrvar).name()<<endl; 

           }

    catch (bad_typeid){

       cout<<"The object is NULL"<<endl;

       }

    return 0;

}

Output:

// domain_error and typeid()

#include <iostream>

usingnamespace std;

int main()

{

  try

   {

     throw domain_error("Some error with your domain!");

   }

  catch (exception &err)

   {

      cerr<<"Caught: "<<err.what()<<endl;

      cerr<<"Type: "<<typeid(err).name()<<endl;

   };

    return 0;

}

Output:

// invalid_argument

#include <bitset>

#include <iostream>

usingnamespace std;

int main()

{

  try

   {

// binary wrongly represented by char X, a template based…

bitset<32> bitset(string("0101001X01010110000"));

   }

  catch (exception &err)

   {

      cerr<<"Caught "<<err.what()<<endl;

      cerr<<"Type "<<typeid(err).name()<<endl;

   };

    return 0;

}

Output:

// runtime_error

#include <iostream>

usingnamespace std;

int main()

{

  // runtime_error

  try

   {

      locale testlocale("Something");

   }

  catch(exception &err)

   {

      cerr<<"Caught "<<err.what()<<endl;

      cerr<<"Type "<<typeid(err).name()<<endl;

   };

    return 0;

}

Output:

// overflow_error, storage reserved is not enough

#include <bitset>

#include <iostream>

usingnamespace std;

int main()

{

  try

   {

     // a template based…

      bitset<100> bitset;

      bitset[99] = 1;

      bitset[0] = 1;

        // to_ulong(), converts a bitset object to the integer

        // that would generate the sequence of bits

     unsigned long Test = bitset.to_ulong();

   }

  catch(exception &err)

   {

      cerr<<"Caught "<<err.what()<<endl;

      cerr<<"Type "<<typeid(err).name()<<endl;

   };

    return 0;

}

Output:

// range_error

#include <iostream>

usingnamespace std;

int main()

{

  try

   {

     throw range_error("Some error in the range!");

   }

  catch(exception &Test)

   {

      cerr<<"Caught: "<<Test.what()<<endl;

      cerr<<"Type: "<<typeid(Test).name()<<endl;

   };

   return 0;

}

Output:

// underflow_error, the negative storage...

#include <iostream>

usingnamespace std;

int main()

{

  try

   {

     throw underflow_error("The negative storage?");

   }

  catch(exception &Test)

   {

      cerr<<"Caught: "<<Test.what()<<endl;

      cerr<<"Type: "<<typeid(Test).name()<<endl;

   };

 return 0;

}

Output:

• Program example compiled usingg++.

// ***********-except.cpp-***********

// exception, class and destructor

#include <iostream>

using namespace std;

// a prototype...

void TestFunct(void);

// class Test1 declaration...

class Test1

{

        public:

            Test1(){ };

            ~Test1(){ };

            const char *TestShow() const

            {

                cout<<"In class member function *TestShow():\n";

                return "  Exception in Test1 class.";

            }

};

// another class declaration, DestrTest...

class DestrTest

{

        public:

            DestrTest();

            ~DestrTest();

};

// constructor class implementation

DestrTest::DestrTest()

{

        cout<<"Next, in constructor DestrTest():\n";

        cout<<"  Constructing the DestrTest...\n";

}

// destructor class implementation

DestrTest::~DestrTest()

{

        cout<<"Next, in destructor ~DestrTest():\n";

        cout<<"  Destructing the DestrTest...\n";

}

void TestFunct()

{

        // instantiate an object, constructor invoked...

        DestrTest p;

        cout<<"Next in TestFunct(): \n  Throwing Test1 type exception...\n";

        // first throw...

        throw Test1();

}

int main()

{

        cout<<"Starting in main()...\n";

        try

        {

                cout<<"Now, in the try block: \n  Calling TestFunct()...\n";

                TestFunct();

        }

        // instantiate another object, constructor invoked...

        catch(Test1 q)

        {

                cout<<"Next, in catch handler:\n";

                cout<<"  Caught Test1 type exception...\n";

                cout<<q.TestShow()<<"\n";

        }

        catch(char *strg)

        {

                cout<<"Caught char pointer type exception: "<<strg<<"\n";

        }

        cout<<"Back in main...\n";

        return 0;

}

[bodo@bakawali ~]$ g++ except.cpp -o except

[bodo@bakawali ~]$ ./except

Starting in main()...

Now, in the try block:

  Calling TestFunct()...

Next, in constructor DestrTest():

  Constructing the DestrTest...

Next in TestFunct():

  Throwing Test1 type exception...

Next, in destructor ~DestrTest():

  Destructing the DestrTest...

Next, in catch handler:

  Caught Test1 type exception...

In class member function *TestShow():

  Exception in Test1 class.

Back in main...

tenouk fundamental of C++ object oriented tutorial

Further C/C++ exception handling related reading:

1. The source code for this tutorial is available inC/C++ Exception Handling source code.

2. Check the best selling C / C++, Object Oriented and pattern analysis books at Amazon.com.

|< C & C++ Exception Handling 1 | Main | C & C++ Typecasting 1 >|Site Index |Download |

C & C++ Exception Handling: Part 1 | Part 2