EX.NO:1



IMPLEMENTATION OF STATIC MEMBERS DATE:

AIM:

To write a C++ program to demonstrate the static members
ALGORITHM:
Step 1: Start the program.
Step 2: Create a class with static data members and static function.
Step 3: The static value is initialized to zero during object creation. The static value is incremented when a member function set is called for every object. Step
4: We can also reinitialize the static member value during the static member definition.
Step 5: The result is displayed.
Step 6: Stop the process.

PROGRAM:
#include<iostream.h>
#include<conio.h>
class staticmember
{
int a;
static int count,cnt;
public:
void set()



{
a=++count;
cnt++;
}
void show()



{
cout<<"\n";
cout<<"Object Number:"<<a<<"\n";
}
static void showcount()
{
cout<<"Static count value:"<<count<<"\n";
cout<<"Static cnt value:"<<cnt<<"\n";
}
};
int staticmember::count;
int staticmember::cnt = 100;
void main()
{
staticmember s1,s2,s3;
clrscr();
s1.set();

s1.show();
cout<<endl;
s2.set();
staticmember::showcount();
s2.show();
cout<<endl;
s3.set();
staticmember::showcount();
s3.show();
cout<<endl;
getch();
}

OUTPUT: Object Number:1

Static count value:2 Static cnt value:102

Object Number:2

Static count value:3 Static cnt value:103

Object Number:3

RESULT:
Thus the C++ program was executed and the output is verified.

EX.NO :2




CALCULATION OF BANK INTEREST USING DEFAULT ARGUMENT DATE:

AIM:
To calculate bank interest using the concept of default arguments

ALGORITHM:
1. Start the process.
2. Create a class with sufficient data members and two member functions.
3. The default values are specified in the class
4. The two member functions are defined outside the class.
5. The object is created for the class and the member function is called from the main function.
6. The function assigns a default values to the parameter which does not have a matching argument and function call.
7. If the values for the parameter are specified then the default value is not taken.
8. The bank interest is calculated.
9. Display the result.
10. Stop the process.

PROGRAM:
#include<iostream.h>
#include<conio.h>
class arg
{
float sum,amount,p,n,r;
public:
float value(float p,int n,float r=0.15);
void print(char ch='*', int len=13);
};
float arg::value(float p,int n, float r)
{
int year=1;
float sum=p;
while(year<=n)
{
sum=sum*(1+r);
year=year+1;
}
return(sum);
}
void arg:: print(char ch, int len)
{
for(int i=1;i<=len;i++)
cout<<ch;
cout<<"\n";
}
void main()
{
arg a1;

float tot, res;
clrscr();
a1.print();
tot=a1.value(5000,5);
cout<<tot<<endl;
a1.print();
cout<<endl;
res=a1.value(5000,1,0.20);
cout<<res;
getch();
}

OUTPUT:
****************************
10056.786133
****************************
6000

RESULT: Thus the program for calculation of simple interest using default arguments was executed.

EX.NO : 3





MATRIX MULTIPLICATION USING FRIEND FUNCTIONS DATE:

AIM:

To write a program for matrix multiplication using friend functions using C++.

ALGORITHM:
Step 1: Start the program.
Step 2: Create a class Matrix with two matrix array as data member and a function as their member function.
Step 3: Declare a function multiply as a friend function for the class matrix.get the value of the given two matrix using a member function.
Step 4: Calculate the matrix multiplication using friend function. The friend function is called in the main function without the help of the object and object as its arguments.
Step 5: Display the resultant matrix.
Step 6: Stop the program.

PROGRAM:
#include<iostream.h>
#include<conio.h>
class matrix {
int a[5][5],b[5][5],d[5][5];
int i,j,k,l,m,r,c;
public: void get();
friend void multiply(matrix m1);
};
void matrix::get()
{
cout<<"\n Enter the dimension (n*m) of the first matrix:";
cin>>r>>c;
cout<<"\n Enter "<< r*c <<" element:";
for(i=0;i<r;i++)
{
for(j=0;j<c;j++)
{
cin>>a[i][j];
}
}
cout<<"\n The value of the first matrix:";
for(i=0;i<r;i++)
{
cout<<"\n";
for(j=0;j<c;j++)
{


cout<<a[i][j]<<"\t";
}
}
}
void multiply(matrix m1)
{
int i,j,k; char ch='y';
do
{
cout<<"\n Enter the dimension (n*m) for the second matrix:";
cin>>m1.l>>m1.m;
cout<<"\n Enter "<< m1.l*m1.m <<" element:";
for(i=0;i<m1.l;i++)
{
for(j=0;j<m1.m;j++)
{
cin>>m1.b[i][j];
}
}
cout<<"\n The value of the second matrix:";
for(i=0;i<m1.l;i++)
{
cout<<"\n"; for(j=0;j<m1.m;j++)
{
cout<<m1.b[i][j]<<"\t";
}
}
if(m1.r==m1.m)
{
for(i=0;i<m1.l;i++)
{
for(j=0;j<m1.m;j++)
{
m1.d[i][j]=0;
for(k=0;k<m1.m;k++)
m1.d[i][j]=m1.a[i][k]*m1.b[k][j]+m1.d[i][j];
}
}
cout<<"\n Resultant Matrix:";
for(i=0;i<m1.l;i++)
{
cout<<"\n";
for(j=0;j<m1.m;j++)
cout<<m1.d[i][j]<<"\t";

}
}
else cout<<"\n Rows and Columns are inequal; Muliplication is not possible";
cout<<"\n Do you want to multiply one more matrix:"; cin>>ch;
}
while(ch=='y');
}
void main()
{
clrscr();
matrix m1;
m1.get();
multiply(m1);
getch();
}

OUTPUT:
Enter the dimension (n*m) of the first matrix: 2 2

Enter 4 element:1 2 3 4

The value of the first matrix: 1


2 3


4
Enter the dimension (n*m) for the second matrix: 2 2

Enter 4 element:4 5 6 7

The value of the second matrix: 4


5 6


7
Resultant Matrix: 16


19 36


43
Do you want to multiply one more matrix: n

RESULT: Thus the program for matrix multiplication using friend functions was written and executed.

EX.NO: 4


IMPLEMENTATION OF COMPLEX NUMBER OPERATIONS USING DATE:





















OPERATOR OVERLOADING

AIM :
To write a C++ program to implement the complex number operations using operator overloading.

ALGORITHM:
Step 1: Start the process
Step 2: Create a class complex with real and imaginary data members.
Step 3: A parameterized constructor is used here for initializing real and

imaginary data members during object creation.
Step 4: The operators such as +, -,* and / are overloaded. Step 5: In the main function the complex number operations are done with the

help of overloaded operators.
Step 6: The result is displayed.
Step 7: Stop the process.

PROGRAM:
#include <math.h>
#include <iostream.h>
#include <iomanip.h>
#include<conio.h>
class complex
{
private:


float real;






// Real Part
float imag;//
Imaginary Part
public:

complex(float,float);
complex operator +(complex);
complex operator -(complex);
complex operator *(complex);
complex operator /(complex);
void printdata();

};
//



















CONSTRUCTOR
complex::complex(float r=0.0f,float im=0.0f)
{
real=r;



imag=im;
}
complex complex::operator +(complex c)
{
complex tmp=c;

tmp.real=this->real+tmp.real;
tmp.imag=this->imag+tmp.imag;
return tmp;
}
complex complex::operator -(complex c)
{

complex tmp=c;
tmp.real=this->real - tmp.real;
tmp.imag=this->imag - tmp.imag;
return tmp;


}
complex complex::operator *(complex c)
{
complex tmp=c;
tmp.real=(real*tmp.real)-(imag*tmp.imag);
tmp.imag=(real*tmp.imag)+(imag*tmp.real);
return tmp;
}
complex complex::operator /(complex c)
{
complex tmp=c;
float res= (imag*tmp.real)-(real*tmp.imag);
float div=(tmp.real*tmp.real)+(tmp.imag*tmp.imag);
tmp.real=(real*tmp.real)+(imag*tmp.imag);
tmp.real/=div;
tmp.imag= res;
tmp.imag/=div;



return tmp;
}
void complex::printdata()
{
cout<<real<<" + ("<<imag<<")j\n";


}
void main() {
complex c1(5,3),c2(3,2),c3;
// Calls Constructor
clrscr();
c3=c1+c2;


// Calls overloaded +
cout<<"\nComplex addition:\n";
c1.printdata();
c2.printdata();
c3.printdata();

cout<<"\nComplex subtraction:\n";

c3=c1-c2;


// Calls overloaded -

c1.printdata();
c2.printdata();

c3.printdata();
cout<<"\nComplex multiplication:\n";

c3=c1*c2;


// Calls
overloaded * c1.printdata();

c2.printdata();
c3.printdata();

cout<<"\nComplex division:\n";
c3=c1/c2;

// Calls
overloaded /c1.printdata();
c2.printdata();

c3.printdata();
getch();
}

OUTPUT: Complex addition: 5 + (3)j 3 + (2)j 8 + (5)j

Complex subtraction: 5 + (3)j 3 + (2)j 2 + (1)j

Complex multiplication: 5 + (3)j 3 + (2)j 9 + (37)j

Complex division: 5 + (3)j 3 + (2)j 1.615385 + (-0.076923)j

RESULT: Thus the program to implement the complex number operations using operator overloading.

EX.NO : 5
COMPLEX NUMBERS WITH OPERATOR OVERLOADING AND DATE:




























TYPE CONVERSION

AIM:

To write a C++ program to implement complex number class with necessary operator overloading and type conversion

ALGORITHM: Step 1: Start the program. Step 2: Create a class Complex. Step 3: Define the default and two parameterized constructors. One constructor is having two integer arguments and another one will have the two double data type arguments Step 4: Declare the operator function which are going to be overloaded. Step 5: Define the overloaded functions such as +,-,*,/,>>,<<. Step 6: Create the objects and pass the complex values. Step 7: Invoke the overloaded functions. Step 8: Display the converted result. Step 9: Stop the process.

PROGRAM: #include<iostream.h> #include<conio.h> #include<iomanip.h> class complex {
private: float real; float imag; public: complex() {
real=imag=0.0; } complex(int r,int i) //conversion constructor {
real = r; imag = i; } complex(double r, double i)//conversion constructor {
real = r; imag = i; } friend istream& operator>>(istream &, complex &); friend ostream& operator<<(ostream &, complex &); complex operator+(complex);

complex operator-(complex); complex operator*(complex); complex operator/(complex); friend double condou(complex t); //complex–>double }; double condou(complex t) {
return t.real+t.imag; } istream& operator >>(istream &in, complex &c) {
cout<<”\nReal Part:”; in>>c.real; cout<<”Imag Part:”; in>>c.imag; return in; } ostream& operator<<(ostream &out, complex &c) {
if (c.imag<0) out<<c.real<<c.imag<<”i”; else out<<c.real<<”+”<<c.imag<<”i”; return out; } complex complex::operator+(complex c) {
complex temp; temp.real = real+c.real; temp.imag = imag+c.imag; return temp; } complex complex::operator-(complex c) {
complex temp; temp.real = real-c.real; temp.imag = imag-c.imag; return temp; } complex complex::operator*(complex c) {
complex temp; float t=c.real; temp.real = real*c.real-imag*c.imag; temp.imag = real*c.imag+imag*t;

return temp; } complex complex::operator/(complex c) {
complex temp; float qt; float res=(imag*c.real-real*c.imag); qt = c.real*c.real+c.imag*c.imag; temp.real = (real*c.real+imag*c.imag)/qt; temp.imag = res/qt; return temp; } void main() {
complex c1, c2, c3,c4(4,9),c5(3.23004,4.666304444); double t; clrscr(); t=condou(c5); cout<<”\nEnter complex number 1: “; cin>>c1; cout<<”\nEnter complex number 2: “; cin>>c2; cout<<”\nEnter complex numbers are:”; cout<<”\nComplex 1: “<<c1; cout<<”\nComplex 2: “<<c2; c3=c1+c2; cout<<”\nResult of addition is:”<<c3; c3=c1-c2; cout<<”\nResult of subtraction is:”<<c3; c3=c1*c2; cout<<”\nResult of multiplication is:”<<c3; c3=c1/c2; cout<<”\nResult of division is:”<<c3; cout<<”\nInteger–>complex:”<<c4; cout<<”\nDouble–>complex:”<<c5; cout<<”\nConverted to double”<<t; getch(); }

OUTPUT: Enter complex number 1: Real Part:2 Imag Part:4

Enter complex number 2: Real Part:3 Imag Part:5

Enter complex numbers are: Complex 1: 2+4i Complex 2: 3+5i Result of addition is:5+9i Result of subtraction is:-1-1i Result of multiplication is:-14+22i Result of division is:0.764706+0.058824i Integer->complex:4+9i Double->complex:3.23004+4.666305i Converted to double7.896345

RESULT: Thus the program for operator overloading for complex numbers and their type conversions was executed.

EX.NO:6




MATRIX CLASS WITH CONSTRUCTOR, DESTRUCTOR, COPY DATE:




CONSTRUCTOR AND ASSIGNMENT OPERATOR OVERLOADING

AIM:
To implement Matrix class with dynamic memory allocation with constructors, destructor, and overloading of assignment operator.
ALGORITHM: 1. Start the process. 2. Create a class matrix. 3. Declare and define default, parameterized, copy constructor. 4. Define member functions getmatrix and showmatrix. 5. Define destructor. 6. Get the size of the matrix and the elements of the matrix. 7. Depends on the size of the matrix, the memory is allotted for the matrix dynamically. 8. Get the elements of the matrix.
9. Call the copy constructor and copy the values of object m1 to m2. 10. With the help of assignment operator, we are assigning the values of m1 to m3. 11. Display the result. 12. Stop the process.

PROGRAM : #include<iostream.h> #include<conio.h> class matrix {

int **m;
int row, col; public:
matrix()
{

row=col=0;
m=NULL;
}
matrix(int r ,int c);
~matrix();
void getmatrix();
void showmatrix();
matrix(matrix &m2); //copy constructor
matrix& operator=(matrix &m2);

};

matrix::~matrix() {

for(int i=0;i<row;i++)

delete m[i];
delete m; }

matrix::matrix(int r ,int c) {

row=r;
col=c;
m=new int*[row];
for(int i=0;i<row;i++)
m[i]=new int[col]; } matrix::matrix(matrix &m2) {

cout<<"\nCopy constructor invoked\n";
row=m2.row;
col=m2.col;
m=new int*[row];
for(int i=0;i<=row;i++)
m[i]=new int[col];
for(i=0;i<=row;i++)
for(int j=0;j<=row;j++)
m[i][j]=m2.m[i][j]; } matrix& matrix::operator=(matrix &m2) {

cout<<"\nAssignment Operator Overloading\n";
row = m2.row;
col = m2.col;
m = new int*[row];
for(int i=0;i<=row;i++)
m[i]=new int[col];
for(i=0;i<=row;i++)
for(int j=0;j<=row;j++)
m[i][j]=m2.m[i][j];
return *this; } void matrix::getmatrix() {

for(int i=0;i<row;i++)
for(int j=0; j<col; j++)
cin>>m[i][j]; } void matrix::showmatrix() {

for(int i=0;i<row;i++)

{

for(int j=0;j<col;j++)

cout<<"\t"<<m[i][j];

cout<<"\n";
}

} void main() {

int r,c;
clrscr();
cout<<"\nEnter rows and columns of the matrix:\n";
cin>>r>>c;
matrix m1(r,c);
cout<<"\nEnter the matrix elements one by one:\n";
m1.getmatrix();
cout<<"\nEntered matrix is:\n";
m1.showmatrix();
//invoking copy constructor
matrix m2=m1;
cout<<"\nResult of the copy constructor is:\n";
m2.showmatrix();
matrix m3;
m3=m1;
cout<<"\nResult of assignment operator overloading:\n";
m3.showmatrix();
getch(); }

OUTPUT 1: Enter rows and columns of the matrix: 3 2

Enter the matrix elements one by one: 2 3 1 4 5 7

Entered matrix is:



2


3



1


4



5


7

Copy constructor invoked

Result of the copy constructor is:



2


3



1


4



5


7

Assignment Operator Overloading

Result of assignment operator overloading:



2


3



1


4



5


7

OUTPUT 2:
Enter rows and columns of the matrix: 3 3

Enter the matrix elements one by one: 12 23 34 45 56 67 78 89 90

Entered matrix is:



12


23


34



45


56


67



78


89


90

Copy constructor invoked

Result of the copy constructor is:



12


23


34



45


56


67



78


89


90

Assignment Operator Overloading

Result of assignment operator overloading:



12


23


34



45


56


67



78


89


90

RESULT: Thus the program for constructor, destructor, copy constructor and assignment operator overloading was executed.

EX.NO: 7
OVERLOADING NEW AND DELETE OPERATOR DATE:

AIM:

To write a C++ program to implement the overloading of new and delete operators to provide dynamic allocation of memory

ALGORITHM:
Step 1: Start the program.
Step 2: Create a class ‘op’;
Step 3: Declare the overloaded member functions new & delete.
Step 4: Invoke the base class constructor and passing arguments for the new function.
Step 5: The inbuilt identifiers __FILE__ and __LINE__ will get the current file which under processing and the line which currently executing the __LINE__ will be passed.
Step 6: Using malloc the memory will be allocated for the current processing file.
Step 7: Invoke the overloaded operated function delete and pass the pointer variable free the memory which is already allocated.
Step 8: Stop the program.

PROGRAM:
#include<iostream.h>
#include<conio.h>
#include<stdlib.h>
class op
{
public:
void *operator new(size_t size, char const *file,int line);
void operator delete(void *p);
};
void *op::operator new(size_t size, char const *file,int line) {
void *p = malloc(size);
cout<<"\n New called the file:"<<file<<"\n line:"<<line<<"\n size:"<<size<<"\n p:"<<p<<endl;
return p;
}
void op::operator delete(void *p)
{
cout<<"\n Delete called p:"<<p<<endl;
free(p);
}
void main()
{
clrscr();
op *X = new(__FILE__,__LINE__)op;
delete X;
getch();
}
OUTPUT:
New called the file:NEWDEL1.CPP
line:24
size:1
p:0x8fba0df6
Delete called p:0x8fba0df6
RESULT: Thus the C++ program to implement the overloading of new and delete operators to provide dynamic allocation of memory was executed.

EX.NO:
CREATING LINKED LIST USING TEMPLATES DATE:
AIM:
To write a program top perform various operations in a linked list using templates.

ALGORITHM:
Step1: Start the process.
Step2: Declare template class T and include the necessary header files.
Step3: Create a class for linked list node.
Step4: Declare the necessary member function, insert, display ,quit.
Step5: Initialize the head node to NULL.
Step6: Adding values to the tail or end of the list. a. check the head node for NULL. If it is null then new node will be assigned
to head node .And the given input is given to the head node. b. If it is not null, a new node will be created, while the new link node is not equal to null then new value will be appeared to the new node. Step7: Display the list. a. print the nodes if the node is not null. Step 8: Inside main, call and invoke the function and pass the different data types.
Step 9:Display the results.
Step 10:Stop the process.

PROGRAM:
#include<iostream.h>
#include<conio.h>
#include<process.h>
template<class T> class list
{
private:
int data;
list *next;
public:
list()
{
data = 0.0; next = NULL;
}
list(int dat)
{
data =dat;
next = NULL;
}
void insert(list *node);
void display(list *);
};
template<class T> void list<T>::insert(list<T> *node)
{
list *last = this; while(last ->next) last = last ->next; last->next = node; } template<class T> void list<T>::display(list<T> *first)
{
list *traverse;
for(traverse=first;traverse;traverse=traverse->next)
cout<<traverse->data; cout<<endl;
}
void main()
{
int choice1,data;
list<int> *first = NULL;
list<int> *node;
while(1)
{
cout<<"\n Linked list using Templates";
cout<<"\n 1. Insert the element";
cout<<"\n 2. Display the elements:";
cout<<"\n 3. Quit";
cout<<"\n Enter your choice:";
cin>>choice1;
switch(choice1)
{
case 1: cout<<"\n enter data:";
cin>>data;
node=new list<int>(data);
if(first==NULL) first = node;
else first -> insert(node);
break;
case 2: first ->display(first);
break;
case 3: exit(1);
}
}
}
OUTPUT:
Linked list using Templates
1. Insert the element
2. Display the elements:
3. Quit
Enter your choice:1

enter data:12

Linked list using Templates
1. Insert the element
2. Display the elements:
3. Quit
Enter your choice:1

enter data:23

Linked list using Templates
1. Insert the element
2. Display the elements:
3. Quit
Enter your choice:1

enter data:10

Linked list using Templates
1. Insert the element
2. Display the elements:
3. Quit
Enter your choice:2 12 23 10

Linked list using Templates
1. Insert the element
2. Display the elements:
3. Quit
Enter your choice:3

RESULT: Thus the program for linked list using template was executed using C++ .

EX.NO:
IMPLEMENTATION OF BUBBLE SORT DATE:
AIM:
To write a program to implement bubble sort using templates

ALGORITHM:
Step 1:Start the process.
Step 2:Get the number of elements to be sorted.
Step 3:Get the elements from the user.
Step 4:For iteration=1 to n,
a. Assign the first element to the variable “i” and the second element to the variable “j”.
b.Compare the two elements.
c.If the first element is greater than the second element then swap the two values. Else break.
Step 5:Continue the steps 4 until there is no interchange in the current iteration.
Step 6;No interchange indicates the elements are sorted.
Step 7: Stop the process.
PROGRAM:
#include<iostream.h>
#include<iomanip.h>
#include<conio.h>
template <class t> class bubble
{
t a[25];
public: void get(int);
void sort(int);
void display(int);
};
template <class t> void bubble <t>::get(int n)
{
int i;
cout<<"\nEnter the array elements:";
for(i=0; i<n;i++)
cin>>a[i];
}
template <class t> void bubble <t>::display(int n)
{
int i;
cout<<"\nThe sorted array is:\t";
for(i=0;i<n;i++)
cout<<a[i]<<setw(10);
}
template <class t> void bubble <t>::sort(int n)
{
int i,j; t temp;
for(i=0;i<n;i++)
{
for(j=i+1;j<n;j++)
{
if(a[i]>a[j])
{
temp=a[i]; a[i]=a[j]; a[j]=temp;
}
}
}
}
void main() {
int n,m; bubble<int> b1;
bubble<float> b2;
clrscr();
cout<<"\n----Bubble Sort on Integer Values----";
cout<<"\nEnter the size of array:\n";
cin>>n
; b1.get(n);
b1.sort(n);
b1.display(n);
cout<<"\n\n----Bubble Sort on Float values----\n";
cout<<"\nEnter the size of array:\n";
cin>>m;
b2.get(m);
b2.sort(m);
b2.display(m);
getch();
}
OUTPUT: ----Bubble Sort on Integer Values---- Enter the size of array: 5
Enter the array elements: 3 6 1 2 9
The sorted array is:
1
2
3
6
9
----Bubble Sort on Float values----
Enter the size of array: 5
Enter the array elements: 1.2 5.7 3.6 2.0 4.6
The sorted array is:
1.2
2
3.6
4.6
5.7
RESULT: Thus the program to implement Bubble Sort using templates was executed.
EX.NO:
INSERTION SORT USING TEMPLATES DATE:
AIM:
To write a program to implement insertion sort using templates.
ALGORITHM:
Step 1: Start the process.
Step 2: Get the number of elements to be inserted
Step3: Store the elements in an array
Step 4: Fix the index position to the first element.
Step 5: Write a routine for comparing the least element in the array
Step 6: Compare the first element with the next element. If the second element is lesser than the first element, then the first element will be swapped. Likewise, all the elements will be compared in many passes.
Step 7: Once the element have be sorted then the sorting routine will get stop.
Step 8: Stop the process.

PROGRAM:
#include<iostream.h>
#include<iomanip.h>
#include<conio.h>
template <class t> class insertion
{
t a[25];
public:
void get(int);
void sort(int);
void display(int);
};
template <class t> void insertion<t>::get(int n)
{
int i;
cout<<"\nEnter the array elements:";
for(i=0; i<n;i++) cin>>a[i];
}
template <class t> void insertion <t>::display(int n)
{
int i;
cout<<"\nThe sorted array is: \t";
for(i=0;i<n;i++)
cout<<a[i]<<setw(10);
}
template <class t> void insertion <t>::sort(int n)
{
int i,j;
t temp;
for(i=1;i<n;i++)
{
j=i;
while(j>=1)
{
if(a[j]<a[j-1]) {
temp=a[j]; a[j]=a[j-1]; a[j-1]=temp; } j--; } } } void main() {
int n,m;
insertion<int> i1;
insertion<float> i2;
clrscr();
cout<<"\nInsertion Sort on Integer Values\n";
cout<<"\nEnter the size of array:\t";
cin>>n;
i1.get(n);
i1.sort(n);
i1.display(n);
cout<<"\n\nInsertion Sort on Float Values\n";
cout<<"\nEnter the size of array:\t";
cin>>m;
i2.get(m);
i2.sort(m);
i2.display(m);
getch();
}
OUTPUT: Insertion Sort on Integer Values Enter the size of array:
5 Enter the array elements:23 67 12 78 34
The sorted array is:
12
23
34
67
78
Insertion Sort on Float Values Enter the size of array:
3 Enter the array elements:13.3 29.0 12.7
The sorted array is:
12.7
13.3
29
RESULT: Thus the program to implement insertion sort using templates was executed.

EX.NO:
MERGE SORT USING TEMPLATES DATE:
AIM:
To write a program to implement merge sort using templates.
ALGORITHM:
Step 1: Start the process.
Step 2: Get the number of elements to be sorted.
Step 3: At every pass, one element is placed in the correct position.
Step 4: The initially sorted position is null and the complete list is unsorted with every pass, the sorted portion grows by one element and the unsorted portion shrinks by one element.
Step 5: If the interchange has occurred then the current position of the data will be moved.
Step 6: The passes can be stopped if there is no interchange in the current pass. No interchange indicates that the elements are sorted.
Step 7: Stop the process.
PROGRAM:
#include<iostream.h>
#include<conio.h>
#include<iomanip.h>
template<class t> class sort
{
t a[10];
public: void get(int);
void merge(int,int);
void mergesort(int,int,int);
void display(int); };
template<class t> void sort<t>::get(int n)
{
int i;
cout<<"\n\n Enter the Array Elements:";
for(i=1;i<=n;i++)
cin>>a[i];
}
template<class t> void sort<t>::display(int n)
{
int i;
cout<<"\n The Sorted Array is\n";
for(i=1;i<=n;i++)
cout<<a[i]<<setw(5);
}
template<class t> void sort<t>::merge(int low,int high)
{
int mid;
if(low<high)
{
mid=(low+high)/2;
merge(low,mid);
merge(mid+1,high);
mergesort(low,mid,high);
}
}
template<class t> void sort<t>::mergesort(int low,int mid,int high)
{
t b[10];
int h,i,j,k; h=low;
i=low;
j=mid+1;
while((h<=mid)&&(j<=high))
{
if(a[h]<=a[j])
{
b[i]=a[h]; h=h+1;
}
else
{
b[i]=a[j]; j=j+1;
}
i=i+1;
}
if(h>mid)
{
for(k=j;k<=high;k++) {
b[i]=a[k]; i=i+1; } } else {
for(k=h;k<=mid;k++)

{
b[i]=a[k]; i=i+1; } } for(k=low;k<=high;k++) a[k]=b[k]; } void main() {
int n; clrscr(); cout<<"\n\t\t Merge Sort Using Templates"; cout<<"\n\t\t~~~~~~~~~~~~~~~~~~~~~"; sort<int>n1; sort<float>n2; cout<<"\n Enter the Array Size:"; cin>>n; cout<<"\n----Integer values----\n";
n1.get(n);
n1.merge(1,n);
n1.display(n);
cout<<"\n\n----Float values----\n";
n2.get(n);
n2.merge(1,n);
n2.display(n); getch();
}

OUTPUT:
Merge Sort Using Templates
~~~~~~~~~~~~~~~~~~~~~
Enter the Array Size:5 ----Integer values----
Enter the Array Elements:12 45 23 10 78
The Sorted Array is 10
12
23
45
78
----Float values----
Enter the Array Elements:12.4 34.6 67.8 13.9 33.2
The Sorted Array is 12.4
13.9 33.2 34.59 67.8
RESULT: Thus the program to implement Merge Sort using Templates was executed.
EX.NO:
IMPLEMENTATION OF QUICK SORT DATE:
AIM:
To sort the elements using the quick sort.
ALGORITHM: Step 1:Start the process. Step 2:Get the values from the user. Step 3:Position a pointer ‘low’ to the second element and a pointer ‘HIGH’
to the last element. Step 4:Move ‘low’ forward till it reaches an element greater than k1. Step 5:Move ‘high’ backward till it reaches an element less than k1. Step 6:Interchange klow and khigh if low<high. Step 7:Continue steps 2 to 4 till low<high. Step 8:Swaps the elements at first and high indices.

PROGRAM:
#include <iostream.h>
#include <conio.h>
#include <process.h>
template <class T> class QUICK_SORT
{
private: T a[20];
int low, high, size;
public: QUICK_SORT(int n)
{
size=n;
}
void Get_Data();
void Quick(int low, int high);
int Partition(int low, int high);
void Display_Data();
};
template<class T> void QUICK_SORT<T>::Get_Data()
{
cout<<"Enter the elements to be inserted" << endl;
for(int i=0; i<size; i++)
cin >> a[i];
}
template<class T> void QUICK_SORT<T>::Quick(int low, int high)
{
int j;
if(low <= high)
{
j=Partition(low,high);
Quick(low, j-1); Quick(j+1, high); }} template<class T> int QUICK_SORT<T>::Partition(int low, int high) {
int i, j; T key; i = low + 1; j = high; key = a[low]; while(1) {
while(i < high && key >= a[i]) i++; while(key <a[j]) j--; if(i < j) {
T temp = a[i]; a[i] = a[j]; a[j] = temp; } else {
T temp = a[j]; a[j] = a[low]; a[low] = temp; return j; } } //end while }//end QUICK_SORT<T> template<class T> void QUICK_SORT<T>::Display_Data() {
int i; cout << "The sorted list is:"; for(i=0; i<size; i++) cout <<a[i]<<"\t"; cout << endl; } void main() {
int n, ch; clrscr(); cout<<"Enter number of data: "; cin>>n; cout << endl; QUICK_SORT<int>Q1(n); QUICK_SORT<double>Q2(n); cout << "1.To sort integer data " << endl; cout << "2.To sort double data" << endl; cout << "3.To quit" << endl;

cout << "Enter your choice" << endl;
cin >> ch;
switch(ch)
{
case 1: Q1.Get_Data();
Q1.Quick(0,n-1);
Q1.Display_Data();
break;
case 2: Q2.Get_Data();
Q2.Quick(0,n-1);
Q2.Display_Data();
break;
}
getch();
}//end main()

OUTPUT1: Enter number of data: 4 1.To sort integer data 2.To sort double data 3.To quit Enter your choice 2 Enter the elements to be inserted 1.7 2.6 1.9 4.7 The sorted list is:1.7
1.9
2.6
4.7
OUTPUT2: Enter number of data: 4 1.To sort integer data 2.To sort double data 3.To quit Enter your choice 1 Enter the elements to be inserted 12 56 89 23 The sorted list is:12
23
56
89
RESULT: Thus the program for implementation of Quick sort using templates was executed.
EX.NO:
IMPLEMENTATION OF STACK USING EXCEPTION HANDLING DATE:
AIM:
To implement a Stack using exception handling using C++.

ALGORITHM:
Step 1: Start the process.
Step 2: Create a Class Stack.
Step 3: Initialize the top pointer of the stack.
Step 4: Create class full and empty.
Step 5: Create the members push, pop and display.
Step 6: Inside the push function check the top of the stack for overflow. If the top is not equal to the size (n-1) then push the elements onto the stack and increment the top pointer. If the top reaches the maximum size of n then throw the elements on to the stack overflow.
Step 7: Inside the pop function check the stack underflow condition. If the stack is empty, top is equal to zero then deletion cannot be performed, throws a stack underflow exception. Otherwise pop the elements and decrement the pointer.
Step 8: Display the stack elements.
Step 9: Stop the process.
PROGRAM:
 
#include<iostream.h>
#include<iomanip.h>
class stack
{
private: int *s; int max; int top; public: class full{
};
class empty
{
};
stack(int);
void push(int);
int pop(void);
void display(void); };
stack::stack(int m)
{
s=new int[m]; top = -1; max=m;
}
void stack::push(int item)
{
if(top<max-1)
s[++top]=item;
else
throw full();
}
int stack::pop(void)
{
if(top>=0)
return s[top--];
else throw empty();
}
void stack::display(void)
{
if(top>=0)
for(int i = top; i>=0;i--)
cout<<"\n \t |"<<setw(4)<<s[i]<<"|\n\t-----";
else
throw empty();
}
int main()
{
int item,size;
int ch = 1;
cout<<"\n Enter the size of the Stack:";
cin>>size; stack s1(size);
cout<<"\n Stack with exception handling";
cout<<"\n \n MENU \n 1.PUSH \n 2.POP \n3.SHOW THE STACK \n4.EXIT";
cout<<"\n Enter your choice:"; cin>>ch;
do
{
switch(ch)
{
case 1: cout<<"\n Enter the item to push:"; cin>>item;
try {
s1.push(item);
}
catch(stack::full)
{
cout<<"\n Stack Overflow";
}
break;
case 2:
try
{
cout<<"The Popped element is:";
cout<<s1.pop();
}
catch(stack::empty)
{
cout<<"\n Stack is empty"; } break; case 3: cout<<"The stack is....";
try
{
s1.display();
}
catch(stack::empty)
{
{
cout<<"\n Stack empty";
}
break;
case 4: exit(0);
}
cout<<"\n Enter your choice:\t";
cin>>ch;
}
while(ch<5);
return 0;
}
OUTPUT:
[ex@localhost ~]$ vi stack.cpp [ex@localhost ~]$ g++ stack.cpp [ex@localhost ~]$ ./a.out
Enter the size of the Stack:2
Stack with exception handling
MENU
1.PUSH
2.POP
3.SHOW THE STACK
4.EXIT
Enter your choice:1
Enter the item to push:12
Enter your choice:

1
Enter the item to push:34
Enter your choice:

1
Enter the item to push:23

Stack Overflow
Enter your choice:

2 The Popped element is:34
Enter your choice:

3 The stack is....
|
12|
----- Enter your choice:
4

RESULT:
Thus the program to implement the stack using exception handling was executed.

EX.NO:
IMPLEMENTATION OF QUEUE USING EXCEPTION HANDLING DATE:
AIM:
To implement a Queue using exception handling using C++.
ALGORITHM:
Step 1: Start the process.
Step 2: Create a class queue.
Step 3: Initialize the front and rear pointers of the queue.
Step 4: Create the members full, empty, insert, dele and display.
Step 5: Inside the insert function check if rear = max. If rear is not equal to max then add the element to the queue. If rear reaches the max then throw the message “Queue Overflow”.
Step 6: Inside the dele function, check if front = rear. If front is not equal to rear then deletion is possible. If front is equal to the rear, throw the message “Queue Underflow”.
Step 7: Display the queue.
Step 8: Stop the process.

PROGRAM:
#include<iostream>
#include<iomanip>
using namespace std;
class queue
{
private: int *q;
int max, front, rear;
int cnt;
public: class FULL
{
};
//for exception handling
class EMPTY
{
}; //for exception handling
queue(int);
void insert(int);
int dele(void);
void display(void);
};
queue::queue(int m)
{
q=new int[m];
rear=0;
front=0;
cnt=0;
max=m;
}
void queue::insert(int item)
{
if(cnt<max)
{
front = front % max; q[front++]=item;
cnt++;
}
else throw FULL(); //FULL object is thrown
}
int queue::dele(void)
{
if(cnt>0)
{
cnt--; rear = rear % max; return q[rear++];
}
else
throw EMPTY(); //EMPTY object is thrown
}
void queue::display(void)
{
if(cnt>0)
for(int i=0,j=front; i<cnt; i++,j++)
cout<<"|"<<q[j % max]<<"|";
else
throw EMPTY();
}
int main()
{
int item, size; int ch=1;
cout<<"\nEnter the size of the queue…";
cin>>size;
queue q(size);
cout<<"\nQueue Operations using Exception Handling";
cout<<"\n\n\tMENU\n1.INSERT\n2.DELETE\n 3.SHOW QUEUE\n4.EXIT";
cout<<"\nEnter your choice…";
cin>>ch;
do
{
switch(ch)
{
case 1: cout<<"\nEnter the item to insert in to the queue…";
cin>>item;
try
{
q.insert(item);
}
catch(queue::FULL)
//FULL object is caught
{
cout<<"\n***Queue Full***\n";
}
break;
case 2:
try
{
cout<<"\nRemoved Item from the Qis…"<<q.dele();
}
catch(queue::EMPTY) //EMPTY object is caught
{
cout<<"\n***Queue Empty***\n";
}
break;
case 3: cout<<"\nThe Queue is…\n";
try
{
q.display();
}
catch(queue::EMPTY)
{
cout<<"\n***Queue Empty***\n";
}
break;
case 4: exit(0); }
cout<<"\nEnter your choice…";
cin>>ch;
}
while(ch<5);
return 0;
}
OUTPUT: [ex@localhost ~]$ g++ q2.cpp [ex@localhost ~]$ ./a.out
Enter the size of the queue…2 Queue Operations using Exception Handling
MENU
1.INSERT
2.DELETE
3.SHOW QUEUE
4.EXIT

Enter your choice…1 Enter the item to insert in to the queue…12 Enter your choice…1 Enter the item to insert in to the queue…23 Enter your choice…1 Enter the item to insert in to the queue…34

***Queue Full*** Enter your choice…3 The Queue is… |12||23| Enter your choice…2 Removed Item from the Qis…12 Enter your choice…2 Removed Item from the Qis…23 Enter your choice…2 ***Queue Empty*** Enter your choice…3 The Queue is… ***Queue Empty*** Enter your choice…4

RESULT: Thus the program to implement the queue
using exception handling was executed.

EX.NO:
MINIMUM SPANNING TREE DATE:

AIM:
To find the minimum cost spanning tree in a graph using Prims algorithm.

ALGORITHM: Step 1 : Start the process.

Step 2: Create two classes as POINT and ARC.

Step 3: Define a Graph class which represents the collection of Point and Arc objects.

Step 4: Write a method to find a minimum cost spanning tree in a graph.

Step 5: Enter the Number of nodes, source node, destination node, weight for the corresponding edge.

Step6: Repeat step5 until all vertices, edges and weight are defined.

Step 7: The edge does not form a cycle in the graph, for Minimum Spanning Tree.

Step 8: Thus set of edges is connected and form a Minimum Spanning Tree.

Step 9: Display the adjacency matrix for the graph and the minimum total path of all the edges.

Step 10: Stop the process.

PROGRAM: #include<iostream.h> #include<conio.h> #define MAX 50 #define TRUE 1 #define FALSE 0 #define MAXINT 250

class node {
public: int no; node() {
}

node (int a)

{
no = a; } }; class arc {
public: int adj; int weight; arc() {
} arc(int a) {
adj = a; } }; class graph {
public: node nodes[MAX]; arc arcs[MAX][MAX]; graph(int n) {
for(int i=1;i<=n;i++) {
nodes[i].no = 0; for(int j=1;j<=n;j++) arcs[i][j].adj = FALSE; } } void join(node n1, node n2, int w) {
arcs[n1.no][n2.no].adj = w; arcs[n2.no][n1.no].adj = w; }

void displayadj(int n) {
cout<<"\n The adjacency matrix...."; cout<<endl; for(int i = 1; i<=n; i++) {
for(int j = 1; j<=n;j++) cout<<"\t"<<arcs[i][j].adj; cout<<endl; }

cout<<endl; }

void shortpath(int n) {
int lcost[20]; int clost[20],i,j,k,min; for(i = 2; i<=n;i++) {
lcost[i]=arcs[1][i].adj; clost[i]=1; } cout<<"\n Minimum cost spanning tree edges are:\n"; for(i=2;i<=n;++i) {
min=lcost[2]; k=2; for(j=3;j<=n;++j) if(lcost[j]<min) {
min = lcost[j]; k=j; } cout<<"\n"<<k<<"<->"<<clost[k]; lcost[k]=MAXINT; for(j=2;j<=n;++j) if((arcs[k][j].adj<lcost[j])&&(lcost[j]<MAXINT)) {
lcost[j]=arcs[k][j].adj; clost[j]=k; } } } }; int main() {
int n; clrscr(); cout<<"\n Enter total number of nodes..."; cin>>n; graph g(n); cout<<"\n Assigning number for each node..."; for(int i = 1;i<=n;i++) g.nodes[i].no=i; char ch ='y'; int w;

do {
node a,b; cout<<"\n Create path b/w the nodes"; cout<<"\n Enter the source node..."; cin>>a.no; cout<<"\n Enter the destination node..."; cin >>b.no; cout<<"\n Enter the weight:"; cin>>w; g.join(a,b,w); cout<<"\n Want to continue...[y]es or [n]:"; cin>>ch; }while(ch=='y'); g.displayadj(n); g.shortpath(n); cin>>n; getch(); return 0; }

OUTPUT:
Enter total number of nodes...4
Assigning number for each node...
Create path b/w the nodes
Enter the source node...1
Enter the destination node...2
Enter the weight:1
Want to continue...[y]es or [n]:y
Create path b/w the nodes
Enter the source node...1
Enter the destination node...4
Enter the weight:2
Want to continue...[y]es or [n]:y
Create path b/w the nodes
Enter the source node...1
Enter the destination node...3
Enter the weight:2
Want to continue...[y]es or [n]:y
Create path b/w the nodes
Enter the source node...2
Enter the destination node...4
Enter the weight:4
Want to continue...[y]es or [n]:y
Create path b/w the nodes
Enter the source node...2

Enter the destination node...3
Enter the weight:5
Want to continue...[y]es or [n]:y
Create path b/w the nodes Enter the source node...3
Enter the destination node...4
Enter the weight:3
Want to continue...[y]es or [n]:n
The adjacency matrix....
0
1
2
2
1
0
5
4
2
5
0
3
2
4
3
0
Minimum cost spanning tree edges are: 2<->1 3<->1 4<->1

RESULT: Thus the program to find the minimum cost spanning tree in a graph using Prims algorithm was executed.

EX.NO:
DYNAMIC POLYMORPHISM AND RTTI DATE:
AIM:

To write a C++ program to demonstrate a simple test application for dynamic polymorphism.

ALGORITHM:
Step 1: Start the program.
Step 2: Create a class called Point in order to locate the position of the shapes.
Step 3: Create a class called Shape and use virtual function to draw the corresponding shape.
Step 4: Create classes for shapes like Square, Rectangle, Triangle, Circle, Ellipses.
Step 5: Call all the shapes using objects, in main function.
Step 6: Shapes will be drawn with the given values.
Step 7: Shapes can also be drawn by using their address and display their location.
Step 8: Stop the program.

PROGRAM: #include<iostream.h> #include<conio.h> class Point {
public:
int x; int y;
Point(){
}
Point(int tempX, int tempY)
{

x = tempX;
y = tempY;
}
int GetX()
{

return x;
}
int GetY()
{

return y;
}
friend ostream & operator <<(ostream &tempout, Point &tempPoint)
{

tempout<<"("<<tempPoint.GetX()<<tempPoint.GetY()<<")";
return tempout;
} }; class Shape {


Point position;

public:
Shape(){
}
virtual void draw()
{

cout<<"shape is drawm";
} }; class Square:public Shape {

Point leftbottom;
int length;
public:
Square(){
}
Square(Point tleftbottom, int tlength)
{


leftbottom = tleftbottom;

length = tlength;
}
void draw()
{


cout<<"Square is drawn at"<<leftbottom<<"and with length as :"<<length<<"\n";
}
}; class Rectangles : public Shape {

Point leftbottom, lefttop, rightbottom, righttop;
public:
Rectangles(){
}
Rectangles(Point tleftbottom, Point tlefttop, Point trightbottom, Point trighttop)
{


leftbottom = tleftbottom;

lefttop = tlefttop;

rightbottom = trightbottom;

righttop = trighttop;
}
void draw()
{


cout<<"Rectangle is drawn at ("<<leftbottom<<", "<<rightbottom<<")"<<"and"<<"("<<lefttop<<","<<righttop<<")\n";
} }; class Triangle : public Shape {

Point avertex, bvertex, cvertex;

public:
Triangle(){
}
Triangle(Point tavertex, Point tbvertex, Point tcvertex)

{

avertex = tavertex;
bvertex = tbvertex;
cvertex = tcvertex;
}
void draw()
{


cout<<"Triangle is drawn at"<<avertex<<" "<<bvertex<<" "<<cvertex<<"\n";

} }; class Circle: public Shape {

Point center; int radius;
public:
Circle(){
}
Circle(Point tcenter, int tradius)
{

center = tcenter;
radius = tradius;
}
void draw()
{

cout<<"Circle is drawn at"<<" " <<center<<" " <<"and the radius is: "<<radius<<"\n";
} }; class Ellipses: public Shape {

Point center;
int radius; int angle;
public:
Ellipses(){
}
Ellipses(Point tcenter, int tradius, int tangle)
{

center = tcenter;
radius = tradius;
angle = tangle;
}
void draw()
{

cout<<"Ellipse is drawn at"<<center<<"and the radius is"<<radius<<"with an angle"<<angle<<"\n";
}

}; void main() {
clrscr(); cout<<"\n";

Point p1(10,20); Point p2(3,2); Square sq(p1,5); sq.draw(); Rectangles rect(p1,p2,p1,p2); rect.draw(); Circle c(p1,50); c.draw(); Ellipses e(p2,34,23); e.draw(); Triangle t(p1,p2,p1); t.draw(); Shape *s; s=&sq; s->draw(); s=&rect; s->draw(); s=&t; s->draw(); getch(); }

OUTPUT: Square is drawn at(1020)and with length as :5 Rectangle is drawn at ((1020), (1020))and((32),(32)) Circle is drawn at (1020) and the radius is: 50 Ellipse is drawn at(32)and the radius is34with an angle23 Triangle is drawn at(1020) (32) (1020) Square is drawn at(1020)and with length as :5 Rectangle is drawn at ((1020), (1020))and((32),(32)) Triangle is drawn at(1020) (32) (1020)

RESULT: Thus the C++ program to demonstrate a simple test application for dynamic polymorphism was executed.

EX.NO:



OPERATIONS ON COMPLEX NUMBERS USING FILES AS STORAGE DATE:

AIM:

To write a C++ program to perform addition of complex numbers using files.

ALGORITHM:
Step 1: Start the program.
Step 2: Create a class called COMPLEX and create its members: real and imaginary. Step 3: Generate the random numbers by using rand() function.
Step 4: Write the randomly generated numbers in a file called “complex1.txt”.
Step 5: Add the two complex numbers.
Step 6: Store the Resultant complex number in another file called “result.txt”
Step 7: Display the resultant value. Step 8: Stop the program.

PROGRAM:
#include<iostream.h>
#include<conio.h>
#include<fstream.h>
#include<stdlib.h>
#include<time.h>
class complex
{
public: int real;
int imag;
complex(int r, int i)
{
real = r;
imag = i;
}
complex()
{
real = imag = 0;
}
void display(void);
};
void complex::display(void)
{
cout<<real<<((imag<0)?"-i":"+i")<<imag<<"\n";
}
void main()
{
clrscr();
ofstream ocom("complex1.txt");

float real,
imag;
time_t ti;
srand((unsigned) time(&ti));
real = rand()%100;
imag = rand()%100;
ocom<<"("<<real<<((imag<0)?"-i":"+i")<<imag<<")"<<"+";
real = rand()%100;
imag = rand()%100;
ocom<<"("<<real<<((imag<0)?"-i":"+i")<<imag<<")"<<"\n";
ocom.close();
ifstream icom("complex1.txt");
char no,t,ch,op;
icom>>no; icom>>real;
icom>>ch;
icom>>no;
icom>>imag;
imag=(ch=='+')?imag:-imag;
icom>>no;
icom>>op;
complex a(real,imag);
icom>>no;
icom>>real;
icom>>ch;
icom>>no;
icom>>imag;
imag=(ch=='+')?imag:-imag;
icom>>no;
icom>>op;
complex b(real,imag);
complex c;
switch(op)
{
case '+':
c.real = a.real+b.real;
c.imag = a.imag+b.imag;
break;
case '-':
c.real = a.real-b.real;
c.imag = a.imag-b.imag;
break;
case '*':
c.real = (a.real*b.real)-(a.imag*b.imag);
c.imag = (a.real*b.imag)+(a.imag*b.real);
break;
case '/':

float qt;
qt = b.real*b.real+b.imag*b.imag;
c.real = (a.real*b.real+a.imag*b.imag)/qt;
c.imag = (a.imag*b.real-a.real*b.imag)/qt;
break;
default:
cout<<"\n Invalid";
}
cout<<"\n complex 1:";
a.display();
cout<<"\n complex 2:";
b.display();
cout<<"\n Resultant complex:";
c.display();
ofstream out("result.txt");
out<<"("<<c.real<<((c.imag<0)?"-i":"+i")<<c.imag<<")";
out.close();
}

OUTPUT: complex1.txt: (0+i72)+(39+i71) result.txt
(39+i143)

RESULT: Thus the program for addition of complex numbers using files was executed.