You are on page 1of 18

pThere are total 15 pgms in which 3 or 4 pgms are repeated prepare all 

15 pgms for ur external exam  
 
 
#####################################################################################
################## 
1.Write a program to design class complex and perform addition and  
multiplication  
operations. 
#####################################################################################
################### 
source code:‐ 
#include<iostream.h> 
#include<conio.h> 
class complex 
{float areal; 
float aimag; 
float breal; 
float bimag; 
public: 
void getinfo(float,float,float,float); 
void display(); 
void add(float,float,float,float); 
void mul(float,float,float,float);}; 
void complex::getinfo(float x,float y,float z,float w) 
 

mul( x.float cimag.  case 2:c.getch().default:cout<<"\ninvalid choice".  c.}  }while(ch!=3).  ************************************************************************************* *******************  source code:‐  #include<iostream.cin>>ch.cin>>x.  cout<<"\nenter a real number".break.int ch.h>  #include<conio.cin>>z.cout<<"\n2.add(x.y.cout<<areal<<"+"<<aimag<<"i".}  void complex::mul(float areal.  cout<<"\nenter a imaginary number".cout<<"\nEnter u r choice".{areal=x.bimag=w.breal=z.} void  complex::add(float areal.  cout<<"\nenter a imaginary number".float aimag.cin>>y.z.z.  do{cout<<"\n1.w).y.}  ************************************************************************************* *******************  2. Write a program to design class complex and perform subtraction and   division operations.cout<<"\nmultiplication  is"<<creal<<"+"<<cimag<<"i".w.cout<<"\n2nd complex no is:".getinfo(x.MULTIPLICATION".  switch(ch){case 1:c.creal=(areal*breal)‐ (aimag*bimag).cin>>w.float x.cout<<breal<<"+"<<bimag<<"i".float breal.  c.float breal.ADDITION".w).w).float bimag)  {float creal.aimag=y. cout<<"\nenter a real number".}void main()  {clrscr(). break.display().float aimag.z.creal=areal+breal.}void complex::display(){cout<<"\n1st comlex no  is:".h>  class complex  .y.y.float bimag)  {float creal.cimag=aimag+bimag.complex c.cout<<"\naddition  is"<<creal<<"+"<<cimag<<"i".float cimag.z.cimag=(areal*bimag)+(breal*bimag).

{float areal.cout<<breal<<"+"<<bimag<<"i".}.  void complex::getinfo(float x.cimag=aimag‐bimag.float).cout<<"enter a  imaginary number".float).y.cout<<"\nENTER U R CHOICE".  void sub(float.  void div(float.z.float breal.  void display().  cout<<"substraction is"<<creal<<"+"<<cimag<<"i".z.SUBTRACTION".cimag=((areal*bimag)‐ (aimag*breal))/((areal*breal)+(bimag*bimag)).float bimag.float y.float.int ch.cout<<"enter a imaginary  number".}  void complex::div(float areal.cin>>ch.float.cin>>y.complex c.  c.cout<<areal<<"+"<<aimag<<"i".float.getch().  c.getinfo(x.y.float.}  void complex::display()  {cout<<"\n1st comlex no is:".default:cout<<"invalid operation".break.break.cin>>w.float aimag.cin>>x.w).float breal.}  void complex::sub(float areal.float aimag.bimag=w.display().float x.public:  void getinfo(float.float w){areal=x.}  .cout<<"\n2.creal=((areal*breal)+(aimag*bimag))/((areal*breal)+(bimag*bimag)).  switch(ch){  case 1:  c.div(x.z.aimag=y.float cimag.float).cout<<"\n2nd complex no  is:".z.creal=areal‐breal.case 2:c.DIVISION".float breal.}  void main(){clrscr().w).w).  do  {cout<<"\n 1.float.float bimag)  {float creal. cout<<"enter a real number".y.float bimag)  {float creal.float aimag.breal=z.sub(x.float  cimag.}}while(ch!=3).float z.cout<<"enter a real number".cin>>z.y.w.  cout<<"division is" <<creal<<"+"<<cimag<<"i".float.

 }   void display(int m.cout<<"\nEnter two integer numbers:".char b.Write a program to implement template function swap().   swap(x.y).    cin>>m>>n.x=y.   cout<<"\n Values of m and n after swap:"<<m<<"\t"<<n<<"\n".n).   cout<<"\n Values of a and b before swap:"<<a<<"\t"<<b<<"\n".b.   swap(m.h>#include<conio.    cin>>a>>b.   cout<<"\n Values of x and y before swap:"<<x<<"\t"<<y<<"\n".int n.  .float y)   { cout<<"\n Values of m and n before swap"<<m<<"\t"<<n<<"\n".  ************************************************************************************* *******************  source code:‐  #include<iostream.************************************************************************************* *******************  3.   cout<<"\n Values of a and b after swap:"<<a<<"\t"<<b<<"\n".b).float x. clrscr().char a.y=temp. char a.h>   template<class T> void swap(T &x.   swap(a.   cout<<"\n Values of x and y after swap:"<<x<<"\t"<<y<<"\n".  }   void main()   { int m.y.    cout<<"\nEnter two characters:".float x.    cout<<"\n Enter two float numbers".n.T &y)   { T temp=x.

y).b.  ************************************************************************************* *******************  source code:‐    #include<iostream.}  ************************************************************************************* *******************  5.A4.A3.A2. cout<<"\nNo.  void main(){ clrscr().n.}{ cout<<"\n\nENTER BLOCK2 \n".h>  #include<conio.{ cout<<"\n\nENTER BLOCK1 \n  alpha A5. of objects created"<<count. alpha A1.cout<<"\n\nENTER MAIN\n". count‐‐. cin>>x>>y. alpha A6.   }  ************************************************************************************* *******************  4.Write a program using the concept of constructor and destructor".  class alpha  { public:alpha(){ count++.    cout<<"ELEMENTS AFTER SWAPPING ARE".a.}}.    display(m.Write a program to design class complex and overload + and * operator   using friend function.h>  int count=0. of objects destroyed"<<count.}   ~alpha(){ cout<<"\n No.      getch().x.  getch().}  cout<<"\n\nRe‐Enter Main \n".  .

real*c2.        void display()        {cout<<"Result is".          cout<<"\nEnter the imaginary part of first complex no:".imag).complex).imag=i.c2.        friend complex operator*(complex.h>  class complex{  public:  float real.float i)  //parameterised constructor        {real=r.************************************************************************************* *******************  source code:‐    #include<iostream.imag+c2.real.imag)+(c1.h>  #include<conio.real)‐ (c1.imag=(c1.return(c3). char choice.imag*c2.imag.   complex operator+(complex c1. }    void main(){complex c1.0.return(c3).  }        friend complex operator+(complex. clrscr().          cout<<"Enter the first complex no:".imag*c2.             cout<<"Enetr the second complex no:".imag.real=(c1.real=c1.imag=c1. }complex operator*(complex  c1.c3.          cin>>c1.complex).c3.c3.complex c2) {complex c3.real.  .int s.0.  float imag. complex()              //default constructor          {real=0.c.imag=0.          cout<<"\nEnter the real part of first complex no:".real).cout<<real<<"+"<<imag<<"i".  }        complex(float r.complex c2)  {complex  c3. } }.real+c2.real*c2.c3.ch.          cin>>c1.

display().          c3.MULTIPLICATION:".           cin>>c2.           cin>>c2.          break.          cout<<"Result of addition is".        cout<<"\n\nENTER YOUR CHOICE:".           cout<<"\nEnter the imaginary part of second complex no:".          cout<<"Result of miltiplication is".          c4.          .        switch(ch)        {         case 1:          complex c3=operator+(c1.        cout<<"\n3.imag.display().cout<<"\n1.c2).EXIT".           do         {cout<<"\n\nOPERATIONS ON COMPLEX NUMBERS:".         cout<<"\nEnter the real part of second complex no:".        cin>>ch.ADDITION:".real.          break.                case 3:          complex c4=operator*(c1.c2).        cout<<"\n2.

                   }while(ch!=3).float i)  //parameterised constructor        {real=r.imag=i. float imag.  ************************************************************************************* *******************    source code:‐    #include<iostream.h>  #include<conio.                }         }      getch(). Write a program to design class complex and overload ‐ and / operator  using friend function.h>    class complex  { public:float real.  }   .                     default:          cout<<"\n INVALID CHOICE:".complex()              //default constructor        {real=0.    ************************************************************************************* *******************  6.imag=0.        }        complex(float r.0.0.

c2.real)+(c2.real*c2.imag))/((c2.cout<<real<<"+"<<imag<<"i".imag)).imag‐c2.imag))/((c2.         cout<<"\nEnter the real part of first complex no:".c3.real=((c1.imag=((c1.      complex operator‐(complex c1.real.real=c1.imag=c1.complex).real*c2.complex c2)        c3.        c3.complex).complex c2)         {complex c3.imag*c2.         cout<<"Enter the first complex no:".imag*c2.         char choice.real)‐ (c1.imag.        return(c3).         int s.real*c2.  }  void main()        {complex c1.imag*c2.imag)).        friend complex operator/(complex.        return(c3).   }   }.        void display()        {cout<<"Result is".         cout<<"\nEnter the imaginary part of first complex no:".ch.real.real*c2.         cin>>c1.  }        complex operator/(complex c1.real)+(c2.                        {complex c3.imag*c2.real)+(c1.  .c.c3.real‐c2.      friend complex operator‐(complex.         clrscr().

display().       cin>>c1.            c3.imag.        cin>>ch.                case 2:            complex c4=operator/(c1.c2).imag.         cout<<"\nEnter the imaginary part of second complex no:".EXIT".         cin>>c2.        cout<<"\n2.        cout<<"\n3.            cout<<"Result of subtraction is".DIVISION".SUBTRACTION:".         cout<<"\nEnter the real part of second complex no:".real.            break.         cin>>c2.        cout<<"\n\nENTER YOUR CHOICE:".         cout<<"Enetr the second complex no:".        cout<<"\n1.     do    .         {cout<<"\n\nOPERATIONS ON COMPLEX NUMBERS:".c2).        switch(ch)        {                 case 1:            complex c3=operator‐(c1.

T &y)   {  T temp=x.          cout<<"Result of division is".            c4.display().               }                  }while(ch!=3).y=temp. }  .  ************************************************************************************* ****************************    source code:‐    #include<iostream.                }         getch().  ************************************************************************************* ****************************  7.            break.h>     template<class T>   void swap(T &x.Write a program to implement template function swap().h>  #include<conio.                       default:            cout<<"\n INVALID CHOICE:".x=y.

   cout<<"\n Values of a and b before swap:"<<a<<"\t"<<b<<"\n".n.   cout<<"\n Values of a and b after swap:"<<a<<"\t"<<b<<"\n".  char a.b).y).    cin>>x>>y.   swap(a.y.   swap(m.   cout<<"\n Values of x and y after swap:"<<x<<"\t"<<y<<"\n".   swap(x.    cout<<"ELEMENTS AFTER SWAPPING ARE".a.n.   cout<<"\n Values of x and y before swap:"<<x<<"\t"<<y<<"\n". }            .int n.y).b.complex c1.    cin>>m>>n.   cout<<"\n Values of m and n after swap:"<<m<<"\t"<<n<<"\n".    cout<<"\n Enter two float numbers:".  float x.    display(m.    cin>>a>>b.b.    cout<<"\nEnter two integer numbers:".    getch().void display(int m. }   void main() {  int m.    cout<<"\nEnter two characters:".x.char a.complex c2)   {cout<<"\n Values of m and n before swap"<<m<<"\t"<<n<<"\n".char b.n).  clrscr().

h>  int count=0. cout<<"\n\nENTER MAIN\n".A2.}              .   count‐‐.}{ cout<<"\n\nENTER BLOCK2 \n". cout<<"\nNo.  getch(). of objects created"<<count.}}. of objects destroyed"<<count.  ************************************************************************************* ****************************    source code:‐  #include<iostream.} ~alpha()  { cout<<"\n No. alpha A5.A3.  class alpha  { public: alpha(){ count++.  {cout<<"\n\nENTER BLOCK1 \n".h>  #include<conio.A4.}  cout<<"\n\nRe‐Enter Main \n".************************************************************************************* ****************************  8.  alpha A6.   void main()  { clrscr(). alpha A1.Write a program using the concept of constructor and destructor.

}}.    cout << "The volume of the second cube is : " << c2.    cin >> c1.side +2.    getch().Write a program to implement class and object. float volume(){ return(side*side*side). cube c1.    c2.  ************************************************************************************* ****************************  Source code:‐  #include<iostream.volume() << endl.h>  class cube  { public: float side.side.    void main()  { float volume1=0.Write a program to design class ‘time’ and overload ‘+’ and ‘‐‘ operator using friend function.    cout << "Enter the lenght of the cube" << endl.side=c1.  ************************************************************************************* ****************************  source code:‐   Refer the assignment folder which i have given you which u have copied  in u r cd    ************************************************************************************* ****************************  10.volume() << endl.}    .    cout << "The volume of the cube is : " << c1.c2.h>#include<conio.************************************************************************************* ****************************  9.

 &gm.                      circle(100.                      circle(500.}              .Write a program to implement single inheritance.  ************************************************************************************* ****************************  ************************************************************************************* ***  12.70).300.200. "c:\\tc\\bgi " ).      closegraph().************************************************************************************* ***  11.  ************************************************************************************* ****************************    source code:‐#include<graphics.100.    circle(400.  initgraph(&gd.50).h>#include<conio. gm.Write a program in graphics to draw circle of different size.      getch().50).h>  void main()  { int gd=DETECT.

    cin>>b.h>#include<conio.    cout<<"\n Enter the value of second number:".DIVISION".s.MULTIPLICTION".h>   void main()   {  int a.SUBTRACTION".EXIT".ADDITION".    clrscr().    cin>>ch.c.    cout<<"\n4.    cout<<"\n3.    cout<<"\n2.b.ch.    cout<<"\n5.    switch(ch) {        .Write a program to carry out different operationslike addition.    cout<<"\n\nENTER YOUR CHOICE:".    cout<<"\n Enter the value of first number:".multiplication and division using do while and switch case.  subtraction.  ************************************************************************************* ****************************  sorce code:‐#include<iostream.    cin>>a.    cout<<"\n1.************************************************************************************* *******************  13.    do {    cout<<"\n\n Operations to be performed:".

    case 4:     c=a‐b.  }      }while(ch!=5).               cout<<"The result of adition is="<<c. case 1:  c=a+b.  .    break.    case 3:    c=a/b.          cout<<"The result of subtraction is="<<c.   default:  cout<<"\n Invalid Choice:".   case 2:     c=a*b.      break.      cout<<"The result of division is="<<c.}              getch().  break.   cout<<"The result of multiplication is="<<c.              break.

    c2.    getch().volume() << endl.h>class cube{   public:     float side.}}.Write a program to implement single inheritance.side +2.volume() << endl.    void main(){    float volume1=0.     float volume(){ return(side*side*side).    cube c1.side.    cin >> c1.    cout << "The volume of the cube is : " << c1.    cout << "Enter the lenght of the cube" << endl.************************************************************************************* ***************************  14.    cout << "The volume of the second cube is : " << c2.h>#include<conio.Write a program to implement class and object.  ************************************************************************************* ****************************  Source code:‐#include<iostream.}  .side=c1.c2.  ************************************************************************************* **************************  source code:‐ use balguruswami book refer first pgm of single   inheritance      ************************************************************************************* ****************************  15.