UNIT III (2).ppt

Introduction to
C++ Templates and Exceptions
 C++ Function Templates
 C++ Class Templates
 Exception and Exception Handler

C++ Function Templates
 Approaches for functions that implement
identical tasks for different data types
 Naïve Approach
 Function Overloading
 Function Template
 Instantiating a Function Templates

Approach 1: Naïve Approach
 create unique functions with unique
names for each combination of data
types
 difficult to keeping track of multiple
function names
 lead to programming errors

Example
void PrintInt( int n )
{
cout << "***Debug" << endl;
cout << "Value is " << n << endl;
}
void PrintChar( char ch )
{
cout << "Value is " << ch << endl;
}
void PrintFloat( float x )
{
…
}
void PrintDouble( double d )
{
…
}
PrintInt(sum);
PrintChar(initial);
PrintFloat(angle);
To output the traced values, we insert:

Approach 2:Function Overloading
(Review)
• The use of the same name for different C++
functions, distinguished from each other by
their parameter lists
• Eliminates need to come up with many
different names for identical tasks.
• Reduces the chance of unexpected results
caused by using the wrong function name.

Example of Function Overloading
void Print( int n )
{
cout << "Value is " << n << endl;
}
void Print( char ch )
{
cout << "Value is " << ch << endl;
}
void Print( float x )
{
}
Print(someInt);
Print(someChar);
Print(someFloat);

Approach 3: Function Template
• A C++ language construct that allows the compiler
to generate multiple versions of a function by
allowing parameterized data types.
Template < TemplateParamList >
FunctionDefinition
FunctionTemplate
TemplateParamDeclaration: placeholder
class typeIdentifier
typename variableIdentifier

Example of a Function Template
template<class SomeType>
void Print( SomeType val )
{
cout << "Value is " << val << endl;
}
Print<int>(sum);
Print<char>(initial);
Print<float>(angle);
Template parameter
(class, user defined
type, built-in types)
Template
argument

Instantiating a Function
Template
• When the compiler instantiates a template,
it substitutes the template argument for the
template parameter throughout the function
template.
Function < TemplateArgList > (FunctionArgList)
TemplateFunction Call

Summary of Three Approaches
Naïve Approach
Different Function Definitions
Different Function Names
Function Overloading
Different Function Definitions
Same Function Name
Template Functions
One Function Definition (a function template)
Compiler Generates Individual Functions

Class Template
• A C++ language construct that allows the compiler
to generate multiple versions of a class by allowing
parameterized data types.
Template < TemplateParamList >
ClassDefinition
Class Template
TemplateParamDeclaration: placeholder
class typeIdentifier
typename variableIdentifier

Example of a Class Template
template<class ItemType>
class GList
{
public:
bool IsEmpty() const;
bool IsFull() const;
int Length() const;
void Insert( /* in */ ItemType item );
void Delete( /* in */ ItemType item );
bool IsPresent( /* in */ ItemType item ) const;
void SelSort();
void Print() const;
GList(); // Constructor
private:
int length;
ItemType data[MAX_LENGTH];
};
Template
parameter

Instantiating a Class Template
• Class template arguments must be
explicit.
• The compiler generates distinct class
types called template classes or
generated classes.
• When instantiating a template, a
compiler substitutes the template
argument for the template parameter
throughout the class template.

Instantiating a Class Template
// Client code
GList<int> list1;
GList<float> list2;
GList<string> list3;
list1.Insert(356);
list2.Insert(84.375);
list3.Insert("Muffler bolt");
To create lists of different data types
GList_int list1;
GList_float list2;
GList_string list3;
template argument
Compiler generates 3
distinct class types

Substitution Example
class GList_int
{
public:
void Insert( /* in */ ItemType item );
void Delete( /* in */ ItemType item );
bool IsPresent( /* in */ ItemType item ) const;
private:
int length;
ItemType data[MAX_LENGTH];
};
int
int
int
int

Function Definitions for
Members of a Template Class
template<class ItemType>
void GList<ItemType>::Insert( /* in */ ItemType item )
{
data[length] = item;
length++;
}
//after substitution of float
void GList<float>::Insert( /* in */ float item )
{
data[length] = item;
length++;
}

Another Template Example:
passing two parameters
template <class T, int size>
class Stack {...
};
Stack<int,128> mystack;
non-type parameter

Exception
• An exception is a unusual, often
unpredictable event, detectable by
software or hardware, that requires
special processing occurring at runtime
• In C++, a variable or class object that
represents an exceptional event.

 Errors can be dealt with at place error occurs
 Easy to see if proper error checking implemented
 Harder to read application itself and see how code works
 Exception handling
 Makes clear, robust, fault-tolerant programs
 C++ removes error handling code from "main line" of program
 Common failures
 new not allocating memory
 Out of bounds array subscript
 Division by zero
 Invalid function parameters

 Exception handling - catch errors before they occur
 Deals with synchronous errors (i.E., Divide by zero)
 Does not deal with asynchronous errors - disk I/O
completions, mouse clicks - use interrupt processing
 Used when system can recover from error
– Exception handler - recovery procedure
 Typically used when error dealt with in different place than
where it occurred
 Useful when program cannot recover but must shut down
cleanly
 Exception handling should not be used for program
control
 Not optimized, can harm program performance

 Exception handling improves fault-tolerance
 Easier to write error-processing code
 Specify what type of exceptions are to be caught
 Most programs support only single threads
 Techniques in this chapter apply for multithreaded OS as well
(windows NT, OS/2, some UNIX)
 Exception handling another way to return control from
a function or block of code

Handling Exception
• If without handling,
• Program crashes
• Falls into unknown state
• An exception handler is a section of program
code that is designed to execute when a
particular exception occurs
• Resolve the exception
• Lead to known state, such as exiting the
program

Standard Exceptions
 Exceptions Thrown by the Language
– new
 Exceptions Thrown by Standard
Library Routines
 Exceptions Thrown by user code,
using throw statement

When Exception Handling Should Be
Used
 Error handling should be used for
 Processing exceptional situations
 Processing exceptions for components that cannot handle
them directly
 Processing exceptions for widely used components (libraries,
classes, functions) that should not process their own
exceptions
 Large projects that require uniform error processing

Basics of C++ Exception Handling: try,
throw, catch
 A function can throw an exception object if it detects
an error
 Object typically a character string (error message) or
class object
 If exception handler exists, exception caught and
handled
 Otherwise, program terminates

Basics of C++ Exception Handling:
try, throw, catch (II)
 Format
 Enclose code that may have an error in try block
 Follow with one or more catch blocks
– Each catch block has an exception handler
 If exception occurs and matches parameter in catch
block, code in catch block executed
 If no exception thrown, exception handlers skipped and
control resumes after catch blocks
 throw point - place where exception occurred
– Control cannot return to throw point

 throw - indicates an exception has occurred
 Usually has one operand (sometimes zero) of any type
– If operand an object, called an exception object
– Conditional expression can be thrown
 Code referenced in a try block can throw an exception
 Exception caught by closest exception handler
 Control exits current try block and goes to catch
handler (if it exists)
 Example (inside function definition)
if ( denominator == 0 )
throw DivideByZeroException();
– Throws a dividebyzeroexception object

The throw Statement
Throw: to signal the fact that an
exception has occurred; also called
raise
ThrowStatement throw Expression

 Exception handlers are in catch blocks
 Format: catch( exceptionType parameterName){
exception handling code
}
 Caught if argument type matches throw type
 If not caught then terminate called which (by default)
calls abort
 Example:
catch ( DivideByZeroException ex) {
cout << "Exception occurred: " << ex.what() <<'n'
}
– Catches exceptions of type DivideByZeroException

 Catch all exceptions
catch(...) - catches all exceptions
– You do not know what type of exception occurred
– There is no parameter name - cannot reference the object
 If no handler matches thrown object
 Searches next enclosing try block
– If none found, terminate called
 If found, control resumes after last catch block
 If several handlers match thrown object, first one found
is executed

 catch parameter matches thrown object when
 They are of the same type
– Exact match required - no promotions/conversions
allowed
 The catch parameter is a public base class of the
thrown object
 The catch parameter is a base-class pointer/
reference type and the thrown object is a derived-class
pointer/ reference type
 The catch handler is catch( ... )
 Thrown const objects have const in the parameter
type

 Unreleased resources
 Resources may have been allocated when exception
thrown
 catch handler should delete space allocated by new
and close any opened files
 catch handlers can throw exceptions
 Exceptions can only be processed by outer try blocks

The try-catch Statement
try
Block
catch (FormalParameter)
Block
catch (FormalParameter)
TryCatchStatement
How one part of the program catches and processes
the exception that another part of the program throws.
FormalParameter
DataType VariableName
…

Example of a try-catch Statement
try
{
// Statements that process personnel data and may throw
// exceptions of type int, string, and SalaryError
}
catch ( int )
{
// Statements to handle an int exception
}
catch ( string s )
{
cout << s << endl; // Prints "Invalid customer age"
// More statements to handle an age error
}
catch ( SalaryError )
{
// Statements to handle a salary error
}

Execution of try-catch
No
statements throw
an exception
Statement
following entire try-catch
statement
A
statement throws
an exception
Exception
Handler
Statements to deal with exception are executed
Control moves
directly to exception
handler

Throwing an Exception to be
Caught by the Calling Code
void Func4()
{
if ( error )
throw ErrType();
}
Normal
return
void Func3()
{
try
{
Func4();
}
catch ( ErrType )
{
}
}
Function
call
Return from
thrown
exception

Practice: Dividing by ZERO
Apply what you know:
int Quotient(int numer, // The numerator
int denom ) // The denominator
{
if (denom != 0)
return numer / denom;
else
//What to do?? do sth. to avoid program
//crash
}

int Quotient(int numer, // The numerator
int denom ) // The denominator
{
if (denom == 0)
throw DivByZero();
//throw exception of class DivByZero
return numer / denom;
}
A Solution

A Solution
// quotient.cpp -- Quotient program
#include<iostream.h>
#include <string.h>
int Quotient( int, int );
class DivByZero {}; // Exception class
int main()
{
int numer; // Numerator
int denom; // Denominator
//read in numerator
and denominator
while(cin)
{
try
{
cout << "Their quotient: "
<< Quotient(numer,denom) <<endl;
}
catch ( DivByZero )//exception handler
{
cout<<“Denominator can't be 0"<< endl;
}
// read in numerator and denominator
}
return 0;
}

Take Home Message
 Templates are mechanisms for generating functions and
classes on type parameters. We can design a single class
or function that operates on data of many types
– function templates
– class templates
 An exception is a unusual, often unpredictable event that
requires special processing occurring at runtime
– throw
– try-catch

 Rethrowing exceptions
 Used when an exception handler cannot process an
exception
 Rethrow exception with the statement:
throw;
– No arguments
– If no exception thrown in first place, calls terminate
 Handler can always rethrow exception, even if it
performed some processing
 Rethrown exception detected by next enclosing try block

1. Load header
1.1 Function prototype
1 // Fig. 23.2: fig23_02.cpp
2 // Demonstration of rethrowing an exception.
3 #include <iostream>
4
5 using std::cout;
6 using std::endl;
7
8 #include <exception>
9
10 using std::exception;
11
12 void throwException()
13 {
14 // Throw an exception and immediately catch it.
15 try {
16 cout << "Function throwExceptionn";
17 throw exception(); // generate exception
18 }
19 catch( exception e )
20 {
21 cout << "Exception handled in function throwExceptionn";

2. Function call
3. Output
22 throw; // rethrow exception for further processing
23 }
24
25 cout << "This also should not printn";
26 }
27
28 int main()
29 {
30 try {
31 throwException();
32 cout << "This should not printn";
33 }
34 catch ( exception e )
35 {
36 cout << "Exception handled in mainn";
37 }
38
39 cout << "Program control continues after catch in main"
40 << endl;
41 return 0;
42 }
Function throwException
Exception handled in function throwException
Exception handled in main
Program control continues after catch in main

 Exception specification (throw list)
 Lists exceptions that can be thrown by a function
Example:
int g( double h ) throw ( a, b, c )
{
// function body
}
 Function can throw listed exceptions or derived types
 If other type thrown, function unexpected called
 throw() (i.e., no throw list) states that function will not throw any
exceptions
– In reality, function can still throw exceptions, but calls unexpected
(more later)
 If no throw list specified, function can throw any exception

 Function unexpected
 Calls the function specified with set_unexpected
– Default: terminate
 Function terminate
 Calls function specified with set_terminate
– Default: abort
 set_terminate and set_unexpected
 Prototypes in <exception>
 Take pointers to functions (i.E., Function name)
– Function must return void and take no arguments
 Returns pointer to last function called by terminate or unexpected

Uncaught Exception
 Function-call stack unwound when exception
thrown and not caught in a particular scope
 Tries to catch exception in next outer try/catch
block
 Function in which exception was not caught
terminates
–Local variables destroyed
–Control returns to place where function was
called
 If control returns to a try block, attempt made to
catch exception
–Otherwise, further unwinds stack
 If exception not caught, terminate called

Constructors, Destructors and
Exception Handling
 What to do with an error in a constructor?
 A constructor cannot return a value - how do we let
the outside world know of an error?
– Keep defective object and hope someone tests it
– Set some variable outside constructor
 A thrown exception can tell outside world about a
failed constructor
 catch handler must have a copy constructor for
thrown object

UNIT III (2).ppt

Recommended

More Related Content

Similar to UNIT III (2).ppt (20)

More from VGaneshKarthikeyan (20)

Recently uploaded (20)

UNIT III (2).ppt