============================MODULE21=======================================
|                                                                         |
|  The program examples' source codes have been arranged in the same      |
|  order that appeared in the Tutorial. This is unedited and unverified   |
|  compilation. Published as is basis for educational, reacretional and   |
|  brain teaser purposes. All trademarks, copyrights and IPs, wherever    |
|  exist, are the sole property of their respective owner and/or          |
|  holder. Any damage or loss by using the materials presented in this    |
|  tutorial is USER responsibility. Part or full distribution,            |
|  reproduction and modification is granted to any body.                  |
|     Copyright 2003-2005 © Tenouk, Inc. All rights reserved.		  |
|          Distributed through http://www.tenouk.com			        |
|        		                                                        |
|									                    |
===========================================================================
Originally programs compiled using Borland C++. Examples compiled using
VC++/VC++ .Net and gcc or g++ are given at the end of every Module.
For example if you want to compile C++ codes using VC++/VC++ .Net, change
the header file accordingly.  Just need some modification for the header
files...:

-------------------------------------------------
#include <iostream.h>
//for system()
#include <stdlib.h>

...
{
C++ codes...
}
-------------------------------------------------
should be changed to:
-------------------------------------------------
#include <iostream>
//use C++ wrapper to call C functions from C++ programs...
#include <cstdlib>
using namespace std;

...
{
C++ codes...
}
-------------------------------------------------
In VC++/VC++ .Net the iostream.h (header with .h) is not valid anymore.
It should be C++ header, <iostream> so that it comply to the standard.
In older Borland C++ compiler this still works, but not proper any more...
and for standard C/C++ the portability should be no problem or better
you read Module23 at http://www.tenouk.com/Module23.html to get
the big picture...For C codes, they still C codes :o)
=========================================================================
=========================================================================

//C structured exception handling
//and C++ exception handling. For VC++/VC++ .Net change the
//header files to the following accordingly...same for other examples
//#include <iostream>
//using namespace std;

#include <iostream.h>

//function prototype...
void TestCFunct(void);

int main()
{
		//C++ try block...
		try
		{
			//function calls...
			TestCFunct();
		}
		
		//catch block...
		catch(...)
		{
			cout<<"Caught the exception, C style..."<< endl;
		}
		return 0;
}

//function definition...
void TestCFunct()
{
		//structured handling exception... 
		__try
		{
			int p, r = 2, q = 0;
			//exception should be raised here
			//divide by 0...
			p =  r*(10/q);
		}
		__finally
		{
			cout<<"In __finally" << endl;
			//finding the appropriate catch...
		}
}

----------------------------------------------------------------------------------------

//simple try, throw...catch
#include <iostream.h>

int main()
{
		//declare char pointer
		char* buff;

		//try block...
		try
		{
			//allocate storage for char object...
			buff = new char[1024];

			//do a test, if allocation fails...
			if(buff == 0)
			throw "Memory allocation failure!";
			
			//if allocation successful, display
			//the following message, bypass 
			//the catch block...
			else 
			cout<<sizeof(buff)<<" Byte successfully allocated!"<<endl;
		}

			//if allocation fails, catch the type...
			//display message...
			catch(char* strg)
			{
				cout<<"Exception raised: "<<strg<<endl;
			}
		return 0;
}

------------------------------------------------------------------------------------------

//exception: multiple catch blocks
#include <iostream.h>
#include <stdlib.h>

int main () 
{
		try
		{
			char * teststr;
			teststr = new char [10];

			//test, if memory allocation fails then, 
			//throws this error to the matching catch...
			if (teststr == NULL) throw "Allocation failure";
			
			for (int i=0; i<=15; i++)
			{
				//another test, if n>9, throw this error
				//to the respective catch..
				if (i>9) throw i;
				teststr[i]='z';
				cout<<"teststr["<<i<<"] = "<<teststr[i]<<endl;
			}
		}
		
		//catch the error if, i > 9, by displaying some 
		//error message...
		catch (int j)
		{
			cout<<"The exception: ";
			cout<<"index "<<j<<" is out of range"<<endl;
		}
		//catch the error if, allocation fail for *teststr
		//by displaying some error...
		catch (char * strg)
		{
			cout<<"The exception: "<<strg<<endl;
		}
		system("pause");
		return 0;
}

--------------------------------------------------------------------------------------------

//mismatch type, throw integer type
//catch the double type...
#include <iostream.h>
     
void Funct();
     
int main()
{
	try
	{
		Funct();
	}
	catch(double)
	{
		cerr<<"caught a double type..."<<endl;
	}
	return 0;
}

void Funct()
{
	//3 is not a double but int
	throw 3;       
}

---------------------------------------------------------------------------------------------

//exception, class and destructor
#include <iostream.h>

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;
}

---------------------------------------------------------------------------------------------

//empty throw statement
#include <iostream.h>

//this empty throw will be ignored...
void Nothing() throw()
{
		cout<<"In Nothing(), empty throw..."<<endl;
}

void SomeType() throw(double)
{
		cout<<"In SomeType, will throw a double type..."<<endl;
		throw(1.234);
}

void main()
{
		try 
		{
			Nothing();
			SomeType();
		}
		catch (double)
		{
			cout<<"Caught a double..."<<endl;
		}
}

---------------------------------------------------------------------------------------------

#include <iostream.h>
//base class
class Test1 {};
//derived class
class Test2 : public Test1 {};
     
void Funct();
     
int main()
{
		try
		{
			//function call, go to Funct()
			Funct();
		}
		catch(const Test1&)
		{
			cerr<<"Caught a Test1 type, base class..."<<endl;
		}
		return 0;
}
     
//throw function definition
//a throw of Test2 type, derived class...
void Funct()
{
		throw Test2();
		//next, find the catch handler
}

-----------------------------------------------------------------------------------------------

#include <iostream.h>
//exit()
#include <stdlib.h>
//set_terminate()
#include <exception>

void Funct() 
{
		cout<<"Funct() was called by terminate()."<<endl;
		//0-normal exit, non zero-exit with some error
		exit(0);
}

int main() 
{
		try
		{
			set_terminate(Funct);
			//No catch handler for this exception
			throw "Out of memory!"; 
		}
		catch(int)
		{
			cout<<"Integer exception raised."<<endl;
		}
   return 0;
}

------------------------------------------------------------------------------------------------

//exception specification
#include <iostream.h>

//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;
}

--------------------------------------------------------------------------------------

//standard exceptions
//program example
#include <iostream.h>
#include <exception>
#include <typeinfo>

class Test1 
{
	virtual Funct() {}; 
};

int main () 
{
	try {
		Test1 * var = NULL;
		typeid (*var);
		}
catch (std::exception& typevar)
{
	cout<<"Exception: "<<typevar.what()<<endl;
}
	return 0;
}

---------------------------------------------------------------------------------------

//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;
}

------------------------------------------------------------------------------------------

//bad_cast
//Need to enable the Run-Time Type Info,
//rtti of your compiler.  You will learn
//Typecasting in another Module…
#include <typeinfo.h>
#include <iostream>
using namespace 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"; 
   }
}

----------------------------------------------------------------------------------------------

//bad_alloc, first version
//the allocation is OK
#include <new>
#include <iostream>
using namespace std;

int main() 
{
   char* ptr;
   
   unsigned long int 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;
   };
 }

------------------------------------------------------------------------------------------------

//set_unexpected
#include <exception>
#include <iostream>
using namespace std;

void myfunction() 
{
   cout<<"Testing myfunction()."<<endl;
   //terminate() handler
   terminate();
}

int main( ) 
{
   unexpected_handler oldHandler = set_unexpected(myfunction);
   //unexpected() function call
   unexpected();
}

--------------------------------------------------------------------------------------------------

//bad_typeid
#include <typeinfo.h>
#include <iostream>
using namespace 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;
   }
}

---------------------------------------------------------------------------------------------------

//domain_error and typeid()
#include <iostream>
using namespace 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;
   };
}

----------------------------------------------------------------------------------------------------

//invalid_argument
#include <bitset>
#include <iostream>
using namespace std;

int main()
{
   try 
   {
//binary wrongly represented by char X
//template based…
bitset<32> bitset(string("0101001X01010110000"));
   }
   catch (exception &err) 
   {
      cerr<<"Caught "<<err.what()<<endl;
      cerr<<"Type "<<typeid(err).name()<<endl;
   };
}

----------------------------------------------------------------------------------------------------

//runtime_error
#include <iostream>
using namespace std;

int main()
{
   //runtime_error
   try 
   {
      locale testlocale("Something");
   }
   catch(exception &err) 
   {
      cerr<<"Caught "<<err.what()<<endl;
      cerr<<"Type "<<typeid(err).name()<<endl;
   };
}

---------------------------------------------------------------------------------------------------

//overflow_error
//storage reserved is not enough
#include <bitset>
#include <iostream>
using namespace std;

int main()
{
   try 
   {
      //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;
   };
}

-------------------------------------------------------------------------------------------------------

//range_error
#include <iostream>
using namespace 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;
   };
}

------------------------------------------------VC++/VC++ .Net----------------------------------------------------

//underflow_error
//negative storage...
#include <iostream>
using namespace std;

int main()
{
   try 
   {
      throw underflow_error("The negative storage?");
   }
   catch(exception &Test)
   {
      cerr<<"Caught: "<<Test.what()<<endl;
      cerr<<"Type: "<<typeid(Test).name()<<endl;
   };
}

------------------------------------------------------G++--------------------------------------------------------

//***********-except.cpp-***********
//exception, class and destructor
#include <iostream>
using namespace std;

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;
}

===========================================================================================