CPLUS±

/*WRITE A PROGRAM TO SHOW THE USE OF TEMPLATE*/

#include<iostream.h>
#include<conio.h>
template<class T>
class data
{
public:
data(T c)
{
cout<<"\nc="<<c;
cout<<"\nsize in bytes="<<sizeof(c);
}
};
void main()
{
data<char>h('A');
data<int>i(10);
data<float>j(1.2);
getch();

}

----------------------------------------------------------
OUTPUT:-

/*WRITE A PROGRAM TO SHOW FUNCTION TEMPLATE*/

#include<iostream.h>
#include<conio.h>
template<classe>
void exchange(e&a,e&b)
{
et=a;
a=b;
b=t;
}
void main()
{
int x=5,y=8;
cout<<"\nBefore exchange"<<x<<y;
exchange(x,y);
cout<<"\nAfter exchange"<<x<<y;
getch();

}

----------------------------------------------------------
OUTPUT:-

/*WRITE A PROGRAM USING VIRTUAL FUNCTIONS*/

#include<iostream.h>
#include<conio.h>
class base
{
public:
void display()
{
cout<<"\nDisplay base";
}
virtual void show()
{
cout<<"\nShow base";
}
};
class derived:public base
{
public:
void display()
{
cout<<"\nDisplay derived";
}
void show()
{
cout<<"\nShow derived";
}
};
void main()
{
base b;

derived d;
base*bptr;
cout<<"\nbptr points to base";
bptr=&b;
bptr->display();
bptr->show();
cout<<"\nbptr points to derived";
bptr=&d;
bptr->display();
bptr->show();
return0;
}

----------------------------------------------------------
OUTPUT:-

/*WRITE A PROGRAM TO SHOW USE OF THIS POINTER*/

#include<iostream.h>
#include<conio.h>
class person
{
char name[50];
int age;
public:
person(char*s,inta)
{
strcpy(name,s);
age=a;
}
person greater(person&x)
{
if(x.age>=age)
return x;
else
return*this;
}
void display()
{
cout<<"\nName:"<<name;
cout<<"\nAge:"<<age;
}
};
void main()
{
person p1("John",37);
person p2("Ram",29);

person p3("Shyam",43);
person p=p1.greater(p3);
cout<<"\nElder person is:";
p.display();
p=p1.greater(p2);
cout<<"\nElder person is:";
p.display();
}

----------------------------------------------------------
OUTPUT:-

/*WRITE A PROGRAM TO SHOW OVERLOADING OF BINARY OPERATOR*/

#include<iostream.h>
#include<conio.h>
#include<stdio.h>
class complex
{
float x, y;
public:
complex()
{
}
complex(float real,float imag)
{
x=real,y=imag;
}
complex operator+(complex);
void display();
};
complex complex::operator+(complex c)
{
complex temp;
temp.x=x+c.x;
temp.y=y+c.y;
return (temp);
}
void complex::display()
{
cout<<x<<"+i"<<y<<"\n";
}
void main()

{
complex c1, c2, c3;
c1=complex(2.5,1.5);
c2=complex(3.2,1.7);
c3=c1+c2;
cout<<"c1=";
c1.display();
cout<<"c2=";
c2.display();
cout<<"c3=";
c3.display();
}

----------------------------------------------------------
OUTPUT:-

/*WRITE A PROGRAM TO SHOW HIERARCHICAL INHERITANCE*/

#include<iostream.h>
#include<conio.h>
#include<math.h>
class bank
{
char name[20];
int ac_no;
float r;
float t;
int ac_type;
public:
float p;
float ret_si();
float ret_ci();
int chk_ac();
char show_name();
int show_acno();
void detail(void);
void input(void);
};
class current:public bank
{
float s;
float bal;
public:
void si(void);
void display(void);
};
class saving:public bank

{
float c;
float total;
public:
void ci(void);
void display1(void);
};
//-------------------------------------------------------
int bank::chk_ac()
{
cout<<"\n\t\DOLLAR BANK";
cout<<"\n\n\t##Main menu##";
cout<<"\nPress1 for current account";
cout<<"\nPress2 for saving account";
cout<<"\n\nEnter Customer account type:";
cin>>ac_type;
cout<<"\n-----------------------------------------------------------------\n";
return ac_type;
}
void bank::detail(void)
{
cout<<"\nEnter customer name:";
cin>>name;
cout<<"\nEnter customer Account Number:";
cin>>ac_no;
cout<<"\n------------------------------------------------------------------\n";
}
char bank::show_name()
{
cout<<"\nName of Customer:"<<name;
}
int bank::show_acno()
{
cout<<"\nCustomer's accountno:"<<ac_no;
}
void bank::input(void)
{
cout<<"\n\nEnter principal:";
cin>>p;
cout<<"\nEnter Rate:";
cin>>r;
cout<<"\nEnter Time in Years:";
cin>>t;
}
//--------------------------------------------------------------
float bank::ret_si()
{
return t*r;
}
void current::si(void)
{
s=(p*ret_si())/100;
bal=s+p;
}
void current::display(void)
{
show_name();
show_acno();
cout<<"\nAccount type:Current Account";
cout<<"\nAmount recieved from Customer:"<<p;
cout<<"\nInterest on amount:"<<s;
cout<<"\nBalance:"<<bal;
}
//-----------------------------------------------------
float bank::ret_ci()
{
return p*(pow((1+r/100),t));
}
void saving::ci(void)
{
c=ret_ci()-p;
total=p+c;
}
void saving::display1(void)
{
show_name();
show_acno();
cout<<"\nAccount type:Saving Account";
cout<<"\nAmount recieved:"<<p;
cout<<"\nInterest on amount:"<<c;
cout<<"\ntotal amount:"<<total;
}
float main()
{
bank b;
saving s;
current c;
int x;
x=b.chk_ac();
if(x==1)
{
c.detail();
c.input();
c.si();
c.display();
}
if(x==2)
{
s.detail();
s.input();
s.ci();
s.display1();
}
return 0;
}

----------------------------------------------------------
OUTPUT:-

/*WRITE A PROGRAM TO CALL A MEMBER FUNCTION OF A CLASS USING A NON MEMBER FUNCTION*/

#include<iostream.h>
#include<conio.h>
classmember
{
inta,b;
public:
voidputdata(intnum1,intnum2);
voidgetdata();
};
voidmember::putdata(intnum1,intnum2)
{
a=num1;
b=num2;
}
voidmember::getdata()
{
cout<<"a="<<a;
cout<<"\nb="<<b;
}
voiddisplay()
{
memberm;
m.putdata(10,20);
m.getdata();
}
voidmain()
{
display();

}

----------------------------------------------------------

/*WRITE A PROGRAM TO SHOW HYBRID INHERITANCE*/

#include<iostream.h>
#include<conio.h>
class student
{
protected:
int rollnumber;
public:
void getnumber(inta)
{
rollnumber=a;
}
void putnumber()
{
cout<<"\nRollno="<<rollnumber;
}
};
class test:public student
{
protected:
int part1, part2;
public:
void getmarks(intx,inty)
{
part1=x, part2=y;
}
void putmarks()
{
cout<<"\nMarks obtained";
cout<<"\nPart1="<<part1;

cout<<"\nPart2="<<part2;
}
};
class sports
{
protected:
int score;
public:
void getscore(ints)
{
score=s;
}
void putscore()
{
cout<<"\nSports marks="<<score;
}
};
class result:public test,public sports
{
int total;
public:
void display();
};
void result::display()
{
total=part1+part2+score;
putnumber();
putmarks();
putscore();
cout<<"\nTotal score="<<total;
}
void main()
{
result student1;
student1.getnumber(108);
student1.getmarks(60,70);
student1.getscore(50);
student1.display();
}

----------------------------------------------------------
OUTPUT:-

/*WRITE A PROGRAM TO SHOW MULTILEVEL INHERITANCE*/

#include<iostream.h>
#include<conio.h>
class student
{
protected:
int rollno;
public:
void getnumber(int);
void putnumber();
};
void student::getnumber(inta)
{
rollno=a;
}
void student::putnumber()
{
cout<<"Rollno="<<rollno;
}
class test:public student
{
protected:
int sub1;
int sub2;
public:
void getmarks(int,int);
void putmarks();
};
void test::getmarks(intx,inty)
{

sub1=x;
sub2=y;
}
void test::putmarks()
{
cout<<"\nMarks in sub1="<<sub1;
cout<<"\nMarks in sub2="<<sub2;
}
class result:public test
{
protected:
int total;
public:
void display();
};
void result::display()
{
total=sub1+sub2;
putnumber();
putmarks();
cout<<"\nTotal marks="<<total;
}
void main()
{
resultR1;
R1.getmarks(70,90);
R1.getnumber(150);
R1.display();
getch();
}

----------------------------------------------------------
OUTPUT:-

/*WRITE A PROGRAM TO SHOW MULTIPLE INHERITANCE*/

#include<iostream.h>
#include<conio.h>
class A
{
protected:
int m;
public:
void getm(int);
};
class B
{
protected:
int n;
public:
void getn(int);
};
class C:public A,public B
{
public:
void display(void);
};
void A::getm(intx)
{
m=x;
}
void B::getn(inty)
{
n=y;
}

void C::display()
{
cout<<"\nm="<<m;
cout<<"\nn="<<n;
cout<<"\nm*n="<<m*n;
}
void main()
{
C c;
c.getm(10);
c.getn(20);
c.display();
return0;
}

----------------------------------------------------------
OUTPUT:-

/*WRITE A PROGRAM TO SHOW SINGLE INHERITANCE*/


#include<stdio.h>
#include<conio.h>
#include<iostream.h>
class B
{
int a;
public:
int b;
void get_ab();
int get_a();
void show_a();
};
class D:public B
{
int c;
public:
void mul();
void display();
};
void B::get_ab()
{
a=5;
b=10;
}
int B::get_a()
{
return a;
}
void B::show_a()

{}
void D::mul()
{
c=b*get_a();
}
void D::display()
{
cout<<"\na="<<get_a();
cout<<"\nb="<<b;
cout<<"\nc="<<c;
}
int main()
{
clrscr();
D d;
d.get_ab();
d.mul();
d.show_a();
d.display();
cout<<"\nafter b=20";
d.b=20;
d.mul();
d.display();
getch();
}

----------------------------------------------------------
OUTPUT:-