techpreparation-homepage

Home  Interview Questions  Certifications  Aptitude Questions  Tutorials  Placement Papers  Search  Resume  Soft Skills  Video  Forum  Blog


Technical Interview Questions

C++ Interview Questions
C# Interview Questions
C Interview Questions
                              .........More

Aptitude Interview Questions
C ++ Aptitude Question 2
C Aptitude Questions
                              .........More

Tutorials
C Tutorial
C++ Tutorial
                              .........More

Programming Source Codes
C/C++ Source Codes
C# Source Codes
                              .........More

Online Quiz
C Online Quiz
C++ Online Quiz
                              .........More

Soft Skills
Communication Skills
Leadership Skills
                              .........More

 

  

C/C++ Aptitude Questions and Answers



Find the output of the following program
void main()
{
            int a, *pa, &ra;
            pa = &a;
            ra = a;
            cout <<"a="<
}

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.

Find the output of the following program
const int size = 5;
void print(int *ptr)
{
            cout<
}
 
void print(int ptr[size])
{
            cout<
}
 
void main()
{
            int a[size] = {1,2,3,4,5};
            int *b = new int(size);
            print(a);
            print(b);
}

Answer:
            Compiler Error : function 'void print(int *)' already has a body
 
Explanation:
            Arrays cannot be passed to functions, only pointers (for arrays, base addresses)
can be passed. So the arguments int *ptr and int prt[size] have no difference 
as function arguments. In other words, both the functoins have the same signature and
so cannot be overloaded.

Find the output of the following program 
class some{
public:
            ~some()
            {
                        cout<<"some's destructor"<
            }
};
 
void main()
{
            some s;
            s.~some();
}

Answer:
            some's destructor
            some's destructor


Explanation:
            Destructors can be called explicitly. Here 's.~some()' explicitly calls the
destructor of 's'. When main() returns, destructor of s is called again,
hence the result.

Find the output of the following program 
#include

 
class fig2d
{
            int dim1;
            int dim2;
 
public:
            fig2d() { dim1=5; dim2=6;}
 
            virtual void operator<<(ostream & rhs);
};
 
void fig2d::operator<<(ostream &rhs)
{
            rhs <
dim1<<" "<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<
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.

Find the output of the following program 
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.

Page Numbers :   1         2         3         4         5         6         7         8         9

Next >> C/C++ Aptitude Questions and Answers 2

Have a Question ? post your questions here. It will be answered as soon as possible.

Check Placement Papers for more IT Companies Paper