Presentation of: Programming Fundamentals

Presented to: Sir Omair Ashraf Presented by: Aniqa Farwa A.H

Ammarah

Templates

Templates:Definition:

Templates are used to define generic definition of functions or classes.

A template is not related to specific data types and can work with different data types.

Can re-use same code with int, string, etc.

Types of Templates:

There are two types of templates:

Function templatesClass templates

Function Templates: Function templates are special functions that can

operate with generic types.

This allows us to create a function template whose functionality can be adapted to more than one type or class without repeating the entire code for each type.

Same code is re-used for different types

Function Templates: Syntax: template <class T> T FunctionName (Parameter (s));

Function Templates:Example:#include<iostream.h>#include<conio.h> using namespace std; template<class T> void swap(T&x,T &y) {   t temp=x;   x=y;   y=temp;} void fun(int a,int b,float c,float d){   cout<<"\na and b before swaping :"<<a<<"\t"<<b;   swap(a,b);   cout<<"\na and b after

swaping  :"<<a<<"\t"<<b;   cout<<"\n\nc and d before swaping :"<<c<<"\t"<<d;   swap(c,d);   cout<<"\nc and d after swaping  :"<<c<<"\t"<<d;}

void main(){    int a,b;    float c,d;    clrscr();    cout<<"Enter A,B values(integer):";    cin>>a>>b;    cout<<"Enter C,D values(float):";    cin>>c>>d;    fun(a,b,c,d);    getch();}

Function Templates:Output:Enter A, B values (integer): 10  20Enter C, D values (float):    2.50  10.80 A and B before swapping: 10 20A and B after    swapping:  20 10 C and D before swapping: 2.50  10.80C and D after  swapping: 10.80  2.50

Function Templates:Program:

#include<iostream>#include<conio.h>using namespace std;template <class Type> Type Max(Type a, Type b){ if(a>b) return a; else return b;}Void main(){int n;float m;

n=Max(10, 50);cout<<“Maximum of two integers:“<<n<<endl;m=Max(4.8, 2.2);Cout<<“Maximum of two float: “<<m<<endl;getch();}

Output:

Maximum of two integers: 50

Maximum of two floats:4.8

Class Templates

By: Farwa Abdul Hannan

Introduction Class templates are generally

used for data storage classes. Stacks and linked lists are

examples of data storage classes. The examples of these

classes(data storage classes) that we present could store data of only a single basic type.

Example

The example shown, could store data only of type “int” that is:

Example that stores data of a single type:

class Stack {

› private: int st[MAX]; //array of int int top; //index number of top of stack

› public: Stack(); //constructor void push(int var); //takes int as argument int pop(); //returns int value

};

Another example

If we wanted to store data of type long in a stack, we would need to define a completely new class.

Example that stores data of a single type:

class LongStack {

› private: long st[MAX]; //array of longs long top; //index number of top of

stack› public:

LongStack(); //constructor void push(long var); //takes long as

argument long pop(); //returns long

value };

Benefit of class templates

Templates make it possible to use one function or class to handle different data types.

Syntax The basic syntax for

declaring template class:

template <class Type> class Cont {

› …… };

Example

Example of class template that handle variables of all / different data types is shown

// tempstak.cpp // implements stack class as a template #include <iostream.h> using namespace std; const int MAX = 100; //size of array template <class Type> class Stack { private: Type st[MAX]; //stack: array of any type int top; //number of top of stack public: Stack() //constructor { top = -1; } void push(Type var) //put number on stack { st[++top] = var; } Type pop() //take number off stack { return st[top--]; } };

int main() { Stack<float> s1; //s1 is object of class Stack<float> s1.push(1111.1F); //push 3 floats, pop 3 floats s1.push(2222.2F); s1.push(3333.3F); cout << “1: “ << s1.pop() << endl; cout << “2: “ << s1.pop() << endl; cout << “3: “ << s1.pop() << endl; Stack<long> s2; //s2 is object of class Stack<long> s2.push(123123123L); //push 3 longs, pop 3 longs s2.push(234234234L); s2.push(345345345L); cout << “1: “ << s2.pop() << endl; cout << “2: “ << s2.pop() << endl; cout << “3: “ << s2.pop() << endl; return 0; }

Output of previous code

1: 3333.3 //float stack 2: 2222.2 3: 1111.1 1: 345345345 //long stack 2: 234234234 3: 123123123

Flow chart representation

Specification Class templates differ from function

templates in the way they are instantiated.

To create an actual function from a function template, you call it using arguments of a specific type.

ExceptionsBy: Ammarah Khalid

Roll No.:1

Why do we need Exceptions?

Old C language signaled many errors for returning a particular value from the functions.

Setjump() and Longjump() functions were used for handling errors there (very difficult to use).

This approach is not appropriate in C++.

It handles errors in a different way using “Exceptions”.

Exceptions Syntax:

The exception syntax consists of: First of all, there should be an

exception class. Throw Exception (To handle an error) Try Block (A code that uses objects) Catch Block (Catches exception

through member function)

Continue Exception Syntax:

A General Example: // not a working program class AClass //a class { public: class AnError //exception class { }; void Func() //a member function { if( /* error condition */ ) throw AnError(); //throw exception } }; int main() //application { try //try block { AClass obj1; //interact with AClass objects obj1.Func(); //may cause error } catch(AClass::AnError) //exception handler { //(catch block) //tell user about error, etc. } return 0; }

A Code Example: // demonstrates exceptions #include <iostream> using namespace std; const int MAX = 3; //stack holds 3 integers class Stack { private: int st[MAX]; //array of integers int top; //index of top of stack public: class Range //exception class for Stack { //note: empty class body };

Continue.. Stack() //constructor { top = -1; } void push(int var) { if(top >= MAX-1) //if stack full, throw Range(); //throw exception st[++top] = var; //put number on stack } int pop() { if(top < 0) //if stack empty, throw Range(); //throw exception return st[top--]; //take number off stack } };

Continue.. int main() { Stack s1; try { s1.push(11); s1.push(22); s1.push(33); // s1.push(44); //oops: stack full cout << “1: “ << s1.pop() << endl; cout << “2: “ << s1.pop() << endl; cout << “3: “ << s1.pop() << endl; cout << “4: “ << s1.pop() << endl; //oops: stack empty catch(Stack::Range) //exception handler { cout << “Exception: Stack Full or Empty” << endl; } cout << “Arrive here after catch (or normal exit)” << endl; return 0; }

Output:

Specifying Exception Class:

First of all, exception class should be specified as follows:

Class Range { empty class body};

Throwing an Exception: Exception will occur in previous

program if application tries to pop a value when stack is empty and push a value when stack is full.

Throw Range() will perform this task here.

Try Block: Statements that manipulate stack

(class name) objects, are enclosed in try block.

try { //code that operates on objects that

might cause exception }

Exception Handler: Code that handles exceptions is

enclosed in braces, preceded by catch keyword.

catch(stack::Range) { //code that handles exception }

Sequence of Events: Normal execution outside try block. Control enters the try block. An error occurs in try block (in main

function). Member function throws an exception. Control transfers to exception handler.

Multiple Exceptions Example:

// demonstrates two exception handlers #include <iostream> using namespace std; const int MAX = 3; //stack holds 3 integers class Stack { private: int st[MAX]; //stack: array of integers int top; //index of top of stack public: class Full { }; //exception class class Empty { }; //exception class Stack() //constructor { top = -1; } void push(int var) //put number on stack { if(top >= MAX-1) //if stack full, throw Full(); //throw Full exception st[++top] = var; }

Continue.. int pop() //take number off stack { if(top < 0) //if stack empty, throw Empty(); //throw Empty exception return st[top--]; } }; int main() { Stack s1; try { s1.push(11); s1.push(22);

Continue.. s1.push(33); // s1.push(44); //oops: stack full cout << “1: “ << s1.pop() << endl; cout << “2: “ << s1.pop() << endl; cout << “3: “ << s1.pop() << endl; cout << “4: “ << s1.pop() << endl; //oops: stack empty } catch(Stack::Full) { cout << “Exception: Stack Full” << endl; } catch(Stack::Empty) { cout << “Exception: Stack Empty” << endl; } return 0; }

Output:

Exceptions with Arguments:

// exceptions with arguments #include <iostream> #include <string> using namespace std; class Distance //English Distance class { private: int feet; float inches; public class InchesEx //exception class {

Continue.. public: string origin; //for name of routine float iValue; //for faulty inches value InchesEx(string or, float in) //2-arg constructor { origin = or; //store string iValue = in; //store inches } }; //end of exception class Distance() //constructor (no args) { feet = 0; inches = 0.0; }

Continue.. Distance(int ft, float in) //constructor (two

args) { if(in >= 12.0) throw InchesEx(“2-arg constructor”, in); feet = ft; inches = in; } void getdist() //get length from user { cout << “\nEnter feet: “; cin >> feet; cout << “Enter inches: “; cin >> inches;

Continue.. if(inches >= 12.0) throw InchesEx(“getdist() function”, inches); } void showdist() //display distance { cout << feet << “\’-” << inches << ‘\”’; } }; int main() { Distance dist1(17, 3.5); //2-arg constructor Distance dist2; //no-arg constructor dist2.getdist(); //get value //display distances

Continue.. cout << “\ndist1 = “; dist1.showdist(); cout << “\ndist2 = “; dist2.showdist(); } catch(Distance::InchesEx ix) //exception handler { cout << “\nInitialization error in “ << ix.origin << “.\n Inches value of “ << ix.iValue << “ is too large.”; } cout << endl; return 0; }

Output:

Function Nesting: The exception statements need not be

in the try block directly. It can be in a function that is called by

a statement in try block. However, try part must be included

before catch part.

Exceptions and Class Libraries:

The class libraries sold by any developer may contain errors. They can cause problems. These problems can be resolved using Exceptions.

Not for Every Situation: Do not use exceptions for simple

purposes that can be solved using loops and other structures. Use exceptions for handling difficult tasks only because they effect the program size.

Destructors called Automatically:

In exception mechanism, destructors are called automatically. So the space reserved by them is swiped clean easily.

Code in every exception will be reset.

Handling Exceptions: When you catch an exception,

sometimes you terminate your application. Exception mechanism cleans up chores before terminating. In short, it executes destructors. If there is no exception handler, the program is terminated by operating system.

It’s all about..Try-Throw-Catch

THANK YOU