(Uncaught Exceptions) Write a program that illustrates that a function with its own try block does not have to catch every possible error generated within the try. Some exceptions can slip through to, and be handled in, outer scopes.

Question

What will be an ideal response?

Answer 1

```
#include
#include
using namespace std;

// class TestException1 definition
class TestException1 : public runtime_error
{
public:
// constructor specifies error message
TestException1::TestException1( const string &message )
: runtime_error( message ) {}
}; // end class TestException1
```
```
#include
#include
using namespace std;

// class TestException2 definition
class TestException2 : public runtime_error
{
public:
// constructor specifies error message
TestException2::TestException2( const string &message )
: runtime_error( message ) {}
}; // end class TestException2
```
```
#include
#include "TestException1.h"
#include "TestException2.h"
using namespace std;

void f()
{
throw TestException1( "TestException1" );
} // end function f

void g()
{
try
{
f();
} // end try
catch ( TestException2 &t2 ) // catch TestException2
{
cerr << "In g: Caught " << t2.what() << '\n';
} // end catch
} // end function g

int main()
{

try {
g();
} // end try
catch ( TestException1 &t1 ) // catch TestException1
{
cerr << "In main: Caught " << t1.what() << '\n';
} // end catch

return 0;
} // end main
```
In main: Caught TestException1