Aae oop xp_13

Exception Handling and Templates

Objectives
In this lesson, you will learn to:
Handle runtime errors in a program
Create and use templates

©NIIT OOPS/Lesson 13/Slide 1 of 28


Exception Handling
An exception can be defined as an unexpected event
that occurs during the execution of a program and
disrupts the normal flow of instructions.
C++ reacts in the following ways when an exception
occurs:
The function in which the exception has occurred
may generate a system-defined message.
The function may terminate completely.
The function may skip the intermediate levels and
proceed to another section.



When to Use Exceptions
There can be three types of outcomes when a
function is called during program execution.
Normal Execution- In normal execution, a function
executes normally and returns to the calling
program.
Erroneous Exception- An erroneous exception
occurs when the caller makes a mistake in passing
arguments or calls the function out of context.
Abnormal Execution- Abnormal execution includes
situations in which conditions outside the
program's control influence the outcome of a
function.



Problem Statement 13.D.1
#include iostream
#include cstring
class String
{
private:
char *str;
public:
String()
{str=0;}



Problem Statement 13.D.1 (Contd..)
String(char *inString)
{str = new char[strlen(inString)+1];
strcpy(str,inString);
}
void replace(char search, char repl)
{ int counter;
for(counter = 0; str[counter] != '0'; counter++)
{if(str[counter] == search)
{str[counter] = repl;}}



}
void display()
{cout str; }};
int main()
{String strObject; //The Object Does Not Contain
Anything
strObject.replace('+',' ');
strObject.display();
return 0;
}



The above code generates the following runtime error:
Segmentation fault (core dumped)



Exception Handling
Exception-handling is a feature of C++ that provides a
standard facility to deal with runtime exceptions.
Exception-handling is implemented in C++ using three
distinct components:
Try- A demarcated block of program statements,
known as the try block
Catch- A set of functions known as the catch-
handlers, which are executed when an exception
occurs
Throw- An expression known as throw, which
indicates to the program to jump to the statements
at another location, ideally an exception-handler.



Execution of try, catch and throw Statements
(Contd..)
The control reaches the try statement by normal
sequential execution. The guarded section within the
try block is executed.
If no exception is thrown during the execution of the
guarded section, the catch block that follow the try
block is not executed.
If an exception is thrown during the execution of the
guarded section, the program searches for a catch
clause that can handle an exception of the type
thrown.
If a matching handler is not found, the predefined
runtime function, terminate(), is called.


Exception Handling (Contd..)
If a matching catch handler is found, its parameter is
initialized and the instructions in the catch-handler are
executed.
A handler for a base class will also handle exceptions
for the classes derived from that class.



Problem Statement 13.D.2
Make appropriate changes in the following program.
So that execution of the program does not halt.
#include iostream
#include cstring
class String
{private:
char *str;
public:
String()
{str=0;}



String(char *inString)
{str = new char[strlen(inString)+1];
strcpy(str,inString);
}
void replace(char search, char repl)
{int counter;
for(counter = 0; str[counter] != '0'; counter++)
{if(str[counter] == search){
str[counter] = repl;}}}


void display()
{cout str;
}};
int main()
{ String strObject;
//The Object Does Not Contain Anything
strObject.replace('+',' ');
strObject.display();
return 0;}
Hint: Use try, catch block


UnHandled Exceptions
If an exception is not caught by any catch
statement, then special function terminate will be
called.
The terminate function will terminate the current
process immediately.
It will display an Abnormal termination error
message.
The syntax for terminate method is as follows:
void terminate();



Problem Statement 13.P.1
To avoid the incorrect use of the Customer class, the
class needs to be modified such that an exception is
raised if the state of the object is inappropriate. The
structure for the Customer class is given below:
Customer
MobileNo[11]
Name[25]
DateOfBirth[9]
BillingAddress[51]
City[25]



Problem Statement 13.P.1 (Contd..)
PhoneNo[11]
AmountOutstanding
Get()
Print()
Validate()
Hint:The validate() function should throw an exception if
the data is incorrect.



Types of Exceptions
Synchronous Exceptions- Synchronous exceptions
are those that occur during runtime and can be
generated using the throw expression.
Asynchronous Exceptions- Asynchronous exceptions
are those that occur due to a keyboard or mouse
interrupt.



Tips on Exception-Handling
A try block must be followed by a set of catch
statements.
Once a match is found, the subsequent catch-
handlers are not examined.
A thrown int value of 0 will match char *, since 0
is converted to the NULL pointer. On the other hand,
if a char * is thrown, it never matches an int.
The try block followed by the catch-handlers can be
specified within any function or at any point within the
program.



Tips on Exception-Handling (Contd..)
The statements in the catch-handler determine
whether a program continues to execute after the
handling of an exception.
In C++, try blocks can be nested.
If an exception is thrown before the constructor of an
object is complete, the destructor of the object is not
called.
When an exception is thrown, the catch blocks are
processed in the order in which they are written.
When an exception is thrown, a destructor is called for
any statically created objects that were created by the
code up to that point in the try block.



Just a Minute…
2. The _____, ______, and ________ keywords are
associated with exception-handling in C++.
3. Identify the error in the following code:
#includeiostream
int main()
{ try
{//Statements}
cout One more statement endl;
catch(int var)
{//Statements}



Just a Minute…(Contd..)
catch(...)
{ //Statements }
return 0;
}
Explain the flow of the try, catch, and throw
statements.
When is the terminate() function called, in the
context of exception-handling?
The new operator throws the ____________
exception.



Templates
Templates provide generic functionality.
Templates can be categorized into two categories:
Function Template
Class Template



Function Template
They allow to create generic functions
They admit any data type as parameters
They return a value without having to overload the
function with all the possible data types.
The syntax to declare the function template is as
follows:
template class identifier function_declaration;



Function Template (Contd..)
The syntax to create a template function is as
follows:

template class DT
DT FindoutMax (DT a, DT b)
{
return (ab?a:b);
}
The way to call a template class with a type pattern
is the following:
function pattern (parameters);



Class Template
A class can have members based on generic types
means their data type is not defined at the time of
creation of the class and whose members use these
generic types.
Consider an example to declare a class template:
template class DT
class pair {
DT values [2];
public:
mix (DT first, DT second)
{values[0]=first; values[1]=second;} };


Summary
In this lesson, you learned that:
Exceptions are erroneous events or anomalies
occurring at runtime.
Exception-handling is a feature of C++ provided to
deal with errors in a standard way.
The throw clause throws or raises an exception to
the catch‑handler.
The try block encloses all the program statements
for which a throw expression exists.
Catch‑handlers must follow the try block.



Summary (Contd..)
Each catch‑handler is associated with a throw
expression and performs the required action.
There are two types of exceptions:
Synchronous exceptions
Asynchronous exceptions
Synchronous exceptions are those that occur during
runtime and can be generated using the throw
expression.
Asynchronous exceptions are those that occur due to
a keyboard or mouse interrupt.
Templates provide generic functionality.



Summary (Contd..)
There are two types of templates:
Function Template
Class Template


Aae oop xp_13

More Related Content

What's hot (19)

Viewers also liked (7)

Similar to Aae oop xp_13 (20)

More from Niit Care (20)

Recently uploaded (20)

Aae oop xp_13