Practical No:01 (Complex No)

#include<iostream>
using namespace std;
class complex
{
public:
    float real,img;
    complex()
    {
        real=0;
        img=0;
    }
    complex(float r,float i)
    {
        real=r;
        img=i;
    }
    complex operator+ (complex obj)
    {
        complex temp;
        temp.real=real+obj.real;
        temp.img=img+obj.img;
        return(temp);
    }
    complex operator- (complex obj)
    {
        complex temp;
        temp.real=real-obj.real;
        temp.img=img-obj.img;
        return(temp);
    }
    complex operator* (complex obj)
    {
        complex temp;
        temp.real=real*obj.real-img*obj.img;
        temp.img=img*obj.real+real*obj.img;
        return(temp);   
    }
    complex operator/ (complex obj)
    {
        complex temp;
        float new_temp;
        new_temp=(obj.real*obj.real)+(obj.img*obj.img);
        temp.real=((real*obj.real)+(img*obj.img))/new_temp;
        temp.img=new_temp;
        return(temp);
    }
};
int main()
{
complex a(2,6);
complex b(4,1);
cout<<"\n The first complex num is..";
cout<<a.real<<" and "<<a.img<<"i";
cout<<"\n The second complex num is..";
cout<<b.real<<" and "<<b.img<<"i";
cout<<"\n\n\t\t *******Arithmetic operations******";
complex c=a+b;
cout<<"\n Addition of two complex nums is... ";
cout<<c.real<<" and "<<c.img<<"i"<<endl;
 c=a-b;
cout<<"\n Subtraction of two complex nums is... ";
cout<<c.real<<" and "<<c.img<<"i"<<endl;
 c=a*b;
cout<<"\n Multiplication of two complex nums is... ";
cout<<c.real<<" and "<<c.img<<"i"<<endl;
c=a/b;
cout<<"\n Division of two complex nums is... ";
cout<<c.real<<" and "<<c.img<<"i"<<endl;
return 0;
}

Assignment No:05

Assignment No:05

Q1.What is Files & Streams?
Q2. Explain file Handling Concepts.
Q3. What is STL?  Explain Components of STL.
Q4. Explain Algorithm & STL Vector Class

Q5.  Write note on Basic Searching Sorting Algorithm
Q6. Explain Min-Max Algorithm

**********************************************************************************************

Implement C++/Java/Python program to write a class template to represent a generic vector (PR:09)

CPP program: 

Theory:

Vector

• Vectors are sequence containers representing arrays that can change in size.

Just like arrays, vectors use contiguous storage locations for their elements, which means that their elements can also be accessed using offsets on regular pointers to its elements, and just as efficiently as in arrays. But unlike arrays, their size can change dynamically, with their storage being handled automatically by the container.

• The STL vector class is a template class of sequence containers that arrange elements of a given type in a linear arrangement and allow fast random access to any element. They should be the preferred container for a sequence when random-access performance is at a premium.

   ******************************************************************************************************  

#include<iostream>
using namespace std;
template<class T>
class vector
{
    T v[10];
    int size;
    public:
        void create();
        void modify();
        void multiplication();
        void display();
};
template<class T>
void vector<T>::create()
{
    int i;
    T value;
    char ans;
    size=0;
    do
    {
        cout<<"\nEnter Index and Value:\n";
        cin>>i>>value;
        v[i]=value;
        size++;
        cout<<"\nDo you want enter more elements?";
        cin>>ans;
    }while(ans=='y');
}
template<class T>
void vector<T>::modify()
{
    int key;
    T newvalue;
    cout<<"\nFor modification enter the index of vector:";
    cin>>key;
    cout<<"\nEnter modifyed value";
    cin>>newvalue;
    v[key]=newvalue;
}
template<class T>
void vector<T>::multiplication()
{
    int i,scalarval;
    cout<<"\nEnter scalar";
    cin>>scalarval;
    for(i=0;i<size;i++)
    v[i]=v[i]*scalarval;
}
template<class T>
void vector<T>::display()
{
    int i;
    cout<<"size of vector="<<size<<endl;
    cout<<"Elements in the vector are:\n";
    cout<<"(";
    for(i=0;i<size;i++)
    cout<<v[i]<<"";
    cout<<")";
}
int main()
{
    int ch;
    char ans;
    vector<int>obj;
    cout<<"\n\t------------------------------------------";
    cout<<"\n\tProgram for representing generic vector using class template";
    cout<<"\n\t------------------------------------------";
    do
    {
        cout<<"\nMain Menu";
        cout<<"\n1.Create\n2.Display\n3.Modify\n4.Multiplication";
        cout<<"\nEnter your choice";
        cin>>ch;
        switch(ch)
        {
            case 1:
                obj.create();
                break;
            case 2:
                obj.display();
                break;
            case 3:
                obj.modify();
                break;
            case 4:
                obj.multiplication();
                break;
        }
        cout<<"\nDo you want to continue?(y/n):";
        cin>>ans;
    }while(ans=='y');
    return 0;
}

TRY- THROW-CATCH Statements

#include <iostream>
#include <exception>
using namespace std;

struct MyException : public exception
{
  const char * what () const throw ()
  {
    return "C++ Exception";
  }
};
 
int main()
{
  try
  {
    throw MyException();
  }
  catch(MyException& e)
  {
    std::cout << "MyException caught" << std::endl;
    std::cout << e.what() << std::endl;
  }
  catch(std::exception& e)
  {
    //Other errors
  }
}

Try- Throw- Catch (Exception handeling)

An exception is a problem that arises during the execution of a program. A C++ exception is a response to an exceptional circumstance that arises while a program is running, such as an attempt to divide by zero.
Exceptions provide a way to transfer control from one part of a program to another. C++ exception handling is built upon three keywords: try, catch, and throw.

• throw: A program throws an exception when a problem shows up. This is done using a throw keyword.
• catch: A program catches an exception with an exception handler at the place in a program where you want to handle the problem. The catch keyword indicates the catching of an exception.
• try: A try block identifies a block of code for which particular exceptions will be activated. It's followed by one or more catch blocks.

Assuming a block will raise an exception, a method catches an exception using a combination of the try and catch keywords. A try/catch block is placed around the code that might generate an exception. Code within a try/catch block is referred to as protected code, and the syntax for using try/catch looks like the following:

try
{
   // protected code
}catch( ExceptionName e1 )
{
   // catch block
}catch( ExceptionName e2 )
{
   // catch block
}catch( ExceptionName eN )
{
   // catch block
}

You can list down multiple catch statements to catch different type of exceptions in case your try block raises more than one exception in different situations.

Throwing Exceptions:

Exceptions can be thrown anywhere within a code block using throw statements. The operand of the throw statements determines a type for the exception and can be any expression and the type of the result of the expression determines the type of exception thrown.
Following is an example of throwing an exception when dividing by zero condition occurs:

double division(int a, int b)
{
   if( b == 0 )
   {
      throw "Division by zero condition!";
   }
   return (a/b);
}

Catching Exceptions:

The catch block following the try block catches any exception. You can specify what type of exception you want to catch and this is determined by the exception declaration that appears in parentheses following the keyword catch.

try
{
   // protected code
}catch( ExceptionName e )
{
  // code to handle ExceptionName exception
}

Above code will catch an exception of ExceptionName type. If you want to specify that a catch block should handle any type of exception that is thrown in a try block, you must put an ellipsis, ..., between the parentheses enclosing the exception declaration as follows:

try
{
   // protected code
}catch(...)
{
  // code to handle any exception
}

The following is an example, which throws a division by zero exception and we catch it in catch block.

#include <iostream>
using namespace std;

double division(int a, int b)
{
   if( b == 0 )
   {
      throw "Division by zero condition!";
   }
   return (a/b);
}

int main ()
{
   int x = 50;
   int y = 0;
   double z = 0;
 
   try {
     z = division(x, y);
     cout << z << endl;
   }catch (const char* msg) {
     cerr << msg << endl;
   }

   return 0;
}

Because we are raising an exception of type const char*, so while catching this exception, we have to use const char* in catch block. If we compile and run above code, this would produce the following result:

Division by zero condition!

Assignment No:04

Assignment No:04

Q1. What is mean by Inheritance, Explain its All types with Example? Five Types.

Q2.What is Virtual Function & Ambiguity. explain with Example ?

Q3. What is mean by Binding- Early Binding & late Binding explain with Example

Assignment No:03

Assignment No:03

Q1. What is Operator Overloading explain with Example?

Q2.What is Type Conversion or Type Casting explain with Real & Imaginary No System.