C++ APTITUDES

•      #include <iostream.h>

class fig2d

{

            int dim1;

            int dim2;

public:

            fig2d() { dim1=5; dim2=6;}

            virtual void operator<<(ostream & rhs);

};

void fig2d::operator<<(ostream &rhs)

{

            rhs <<this->dim1<<" "<<this->dim2<<" ";

}

/*class fig3d : public fig2d

{

            int dim3;

public:

            fig3d() { dim3=7;}

            virtual void operator<<(ostream &rhs);

};

void fig3d::operator<<(ostream &rhs)

{

            fig2d::operator <<(rhs);

            rhs<<this->dim3;

}

*/

void main()

{

            fig2d obj1;

//          fig3d obj2;

            obj1 << cout;

//          obj2 << cout;

}

/*

Answer :

            5 6

Explanation:

            In this program, the << operator is overloaded with ostream as argument.

This enables the 'cout' to be present at the right-hand-side. Normally, 'cout'

is implemented as global function, but it doesn't mean that 'cout' is not possible

to be overloaded as member function.

    Overloading << as virtual member function becomes handy when the class in which

it is overloaded is inherited, and this becomes available to be overrided. This is as opposed

to global friend functions, where friend's are not inherited.

*/

•       class opOverload{

public:

            bool operator==(opOverload temp);

};

bool opOverload::operator==(opOverload temp){

            if(*this  == temp ){

                        cout<<"The both are same objects\n";

                        return true;

            }

            else{

                        cout<<"The both are different\n";

                        return false;

            }

}

void main(){

            opOverload a1, a2;

            a1= =a2;

}

Answer :

            Runtime Error: Stack Overflow

Explanation :

            Just like normal functions, operator functions can be called recursively. This program just illustrates that point, by calling the operator == function recursively, leading to an infinite loop.

•       class complex{

            double re;

            double im;

public:

            complex() : re(1),im(0.5) {}

            bool operator==(complex &rhs);

            operator int(){}

};

bool complex::operator == (complex &rhs){

            if((this->re == rhs.re) && (this->im == rhs.im))

                        return true;

            else

                        return false;

}

int main(){

            complex  c1;

            cout<<  c1;

}

Answer : Garbage value

Explanation:

            The programmer wishes to print the complex object using output

re-direction operator,which he has not defined for his lass.But the compiler instead of giving an error sees the conversion function

and converts the user defined object to standard object and prints

some garbage value.

•        class complex{

            double re;

            double im;

public:

            complex() : re(0),im(0) {}

            complex(double n) { re=n,im=n;};

            complex(int m,int n) { re=m,im=n;}

            void print() { cout<<re; cout<<im;}  

};

void main(){

            complex c3;

            double i=5;

            c3 = i;

            c3.print();

}

Answer:

            5,5

Explanation:

            Though no operator= function taking complex, double is defined, the double on the rhs is converted into a temporary object using the single argument constructor taking double and assigned to the lvalue.

•           void main()

{

            int a, *pa, &ra;

            pa = &a;

            ra = a;

            cout <<"a="<<a <<"*pa="<<*pa <<"ra"<<ra ;

}

Answer :

            Compiler Error: 'ra',reference must be initialized

Explanation :

            Pointers are different from references. One of the main

differences is that the pointers can be both initialized and assigned,

whereas references can only be initialized. So this code issues an error.