Scribd
Upload
3 views

Notes Exception & Templates

The document discusses type conversion in C++, detailing three types: basic-to-class, class-to-basic, and class-to-class conversion, with examples for each. It also covers handling uncaught exceptions using methods like terminate(), set_terminate(), and catch(…). Additionally, it introduces templates in C++ for generic programming, explaining function and class templates with examples demonstrating their usage.

Uploaded by

Abhishek Rath
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
3 views

Notes Exception & Templates

The document discusses type conversion in C++, detailing three types: basic-to-class, class-to-basic, and class-to-class conversion, with examples for each. It also covers handling uncaught exceptions using methods like terminate(), set_terminate(), and catch(…). Additionally, it introduces templates in C++ for generic programming, explaining function and class templates with examples demonstrating their usage.

Uploaded by

Abhishek Rath
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 9

Type Conversion

(Conversion involving object of a class)


i.e the statements of the form:
objectname=value/variable;
variable=objectname;
object1=object2;

All contain an object used in assignment (= operation) for which we need to


write codes/ type conversion routines.
Type conversion is of 3 types
1) Basic-to-class conversion
2) Class-to-basic conversion
3) Class-to-class conversion
Basic-to-class conversion
Happens for the assignment: objectname=value/variable;
Here the R.H.S has a basic/predefined data type (variable/value) which is
copied to a class data type (object)
Here the class should contain a parametrized constructor with 1 argument as
basic data type.
Ex:
class A
{
int a,b;
Public:
A(){ a=20,b=30;}
A(int k){ a=b=k;}
void show(){ cout<<a<<b;}
};
void main()
{
A obj;
obj=50; // 50 is passed to parametrized constructor
obj.show(); //Result 50 50
}
Class-to-basic conversion
Happens for the assignment: variable=objectname;
Here the R.H.S has a class data type (object) which is copied to a basic data
type (variable)
Here the class should contain an operator function called typecast operator:
operator basic_data_type()
{
return value;
}
Ex:
class A
{
int a,b;
Public:
A(){ a=20,b=30;}
operator int()
{
return (a+b);
}
};
void main()
{
A obj;
int k=10;
k=obj;
cout<<k; // output 50 taken from operator function
}
Class-to-class conversion
Happens for the statement
obj1=obj2;
where obj1 and obj2 are objects of two different classes.
Let A is the classname for obj1 (called destination class)
And B= classname for obj2 (called source class)
B should contain an operator function and A should contain parametrized
constructor.
Example:
(Rupee to Dollar conversion)
class Dollar
{
float d;
public:
Dollar(){ d=0.0f;}
Dollar(float r){ d=r/85.4;}
void show()
{
cout<<”No of Dollars “<<d;
}
};
Class Rupee
{
float r;
Public:
Rupee(){ cout<<”Input rupees”; cin>>r;}
operator Dollar()
{
return Dollar(r);
}
};
Void main()
{
Rupee ob1;
Dollar ob2;
ob2=ob1;//class-to-class conversion
ob2.show();
}
Handling Uncaught Exceptions
3 methods to handle unknown/uncaught exceptions
1. terminate ()
2. set_terminate()
3. catch(…)
terminate()
 Method to kill any uncaught exception. (for which no catch block is found)
 Usually kept at end of program ( before } of main())
Example: terminate();
set_terminate()
 Method which calls another method for execution when any unknown/uncaught
exception happens.
Example
void myhandler()
{
cout << "Inside new terminate handler\n";
}
int main()
{
// set new terminate handler
set_terminate(myhandler); //myhandler is the function to be called
try {
cout << "Inside try block\n";
throw 100;
}
catch (char a) // won't catch an int exception
{
cout << "Inside catch block\n";
}
return 0;
}

catch(…)
Called as UNIVERSAL CATCH HANDLER which can handle any type of UNHANDLED
exception. Usually kept after all catch() handlers.
Example
Main()
{
try
{
throw 10;
throw ‘a’;
throw 2.5;
}
catch(int)
{
cout<<”exception caught”;
}
catch(…)
{
cout<<”all exceptions caught”;
}
}
Output:
Exception caught
All exceptions caught
All exceptions caught

Here throw 10; moves to catch(int) whereas for other throw statements respective catch() are
missing, so it calls catch(…) on remaining occasions.

Templates
Templates in C++ is an interesting feature that is used for generic programming and
templates in c++ is defined as a blueprint or formula for creating a generic class or a function.

Simply put, you can create a single function or single class to work with different data types
using templates.

Hence a class can create similar set of classes (family of classes)- generic classes

And a function can create a similar set of functions (family of functions)- generic functions

Accordingly, There are two types of templates in C++

 Function template
 Class templates

Function template consists of multiple template functions (generic functions), similarly


class template consists of multiple template classes (generic classes)
Function Templates:
Example:
In this example A template data type (also called generic data type) T is created by user which
is replaced by int, char with values (3,7) and (‘g’, ‘e’) for comparison and produces result:
7 and g respectively.
Overloading in function templates:
Example:
template <class T>
void swap(T a, T b)
{
T c; c=a; a=b; b=c;
cout<<”Results”<<a<<b;
}
void swap(int a, int b)
{
int c; c=a; a=b; b=c;
cout<<”Results”<<a<<b;
}
void main()
{
swap(10,20);// calls swap(int, int)
swap(‘a’,’b’);// calls swap(char, char) replaces T by char
swap(1.5,2.5);// calls swap(float, float) replaces T by float
}
In this example, function template consists of 2 functions, swap(T,T) and swap(int,int).
Hence overloading happens between them.
Class Template
template <class T>
class Test
{
private:
// A variable (answer) of type T so that it can store results of
various types.
T answer;

public:
// Constructor of Test class.
Test(T n) : answer(n)
{
cout << "Inside constructor" << endl;
}

T getNumber()
{
return answer;
}
};

// Main function
int main()
{
// Creating an object with an integer type.
Test<int> numberInt(60);

// Creating an object with double type.


Test<double> numberDouble(17.27);

// Calling the class method getNumber with different data types:


cout << "Integer Number is: " << numberInt.getNumber() << endl;
cout << "Double Number = " << numberDouble.getNumber() << endl;

return 0;
}

Output:

Inside constructor
Inside constructor
Integer Number is: 60
Double Number = 17.27

In this example generic data type T is replaced by int and double inputs to create multiple
copies of the class with T replaced by int and double respectively.

You might also like