Do you meet the following criteria? If yes, send your resume asap to sridhar@interviewmantra.net

• Possess 2 to 5 years of IT Experience.
• Education – BE or MCA.
• Programming experience in C/C++/ Java (Swings, Servlets, JSP, strong OO skills).
• Knowledge of Teamcenter ITK programming is a huge advantage.

Note that this requirement is for Indian National only.

6. What’s the knack with vector<bool>?

The std::vector<bool> is a specialization of the std::vector<> class template, i.e., when an object of vector<bool> is created, it uses a specialized and highly optimized version of the vector<> template, instead of instantiating the template for the bool type. The vector<bool> stores boolean data as bits and not as bool variables (which could take a whole byte to store a single true or a false).

The vector<bool> is optimized on space, rather than on speed, unlike the vector<> template. Moreover, this optimization has been forced upon the users because of the specialization. Also, the vector<bool> items are not addressable and the specialization defines the iterator in a form different than that of vector<> which is not random-access. For more info, check here

7. What is the difference between assignment operator and a copy constructor?

As the names suggest, the copy constructor is used to “construct an object”. The new object is an exact copy of another object that is already constructed. The assignment operator is used to “assign an object” with the value(s) of some other object. Hence, the assignment operator is something that comes into action when we have an object to the LHS of the ‘=’ operator and some expression to the RHS.

For Example:
For some type T and “params” for the object’s constructor,

{
   T x (params1, ...);
   T y (params2, ...);

   T z = x; /* Copy : z created with the value of x */
   y = x+z; /* Assignment : y gets the value equivalent to x+z */
}

If a programmer doesn’t write a copy constructor or an assignment operator, then the compiler provides one. The copy constructor provided by the compiler does a shallow-copy of the objects and, hence, could lead to problems. And, when the programmer overloads the assignment operator for a particular class, s/he must take care of self-assignment and free the resources before the assignment is done.

8. Why we would use exception handling rather than different return values to signal an error?

The probability of a program failing is never zero and, when when such conditions arise, different steps shall be taken. Two options are – Returning an Error code and using Exception Handling.
Returning an error-code is fine but has some problems associated with it:

1. The error-code returned is generally of type “int”. The problem here is that if certain integer values are associated with error-codes, then the function would have to exclude those from the valid return values, which isn’t feasible in all situations.
2. Even if the above is feasible, the code would require code to check the return value for each call and this would cause code bloat.
3. Some error codes are used to signal that the system is in non-recoverable state and needs to exit. This might not be a good thing to be done at all times, for example, if the code that generates the error and terminates the program is part of a library and is being run as a part of a system that can’t be terminated.

The above problems are not seen while using Exception handling because it separates the error-handling code from the program logic. This also makes the code clean and readable.

9. What is RAII?

Resource Acquisition Is Initialization or RAII is a design pattern that helps in creating objects, on the heap, that are safely destructed. The RAII technique requires a wrapper to be used to hold the resource so that when the wrapper object goes out of scope or an exception is thrown, the resource is freed.

For Example:

#include<exception>
#include<iostream>
#include<string>

struct someClass{};

class Wrap
{
   someClass* ptr;
public:
   Wrap() : ptr(0){}
   Wrap(someClass* obptr): ptr(obptr){}

   void setNull()
   {
      if(ptr)
         delete ptr;
      ptr=0;
   }

   void changeRsrc(someClass* obptr)
   {
      if(ptr)
         delete ptr;
      ptr=obptr;
   }

 someClass& operator*()   { return *ptr;}
 someClass* operator->()  { return ptr;}
 ~Wrap(){ std::cout<<"Destructor\n";delete ptr; ptr=0;}
};

void  Foo()
{
 /* someClass *somePtr = new someClass; */

 Wrap wObj(new someClass);
 /* Some Operations on someClass object using wObj */

 throw std::exception();
}

int main()
{
 try
 {
    Foo();
 }catch(std::exception&){std::cout<<"Exception caught\n";}
}

Here, the class Wrap implements the RAII. When Foo() throws an exception, the wObj, being on the stack, invokes its destructor which frees the memory space taken up by the object of someClass. If the somePtr would have been used, then the space allocated by it would not have been freed.
The auto_ptr is a class template, available in C++, that implements the RAII.

10. What is RTTI? What are its uses?

The RTTI or Run-Time Type Identification is a feature of C++ that helps in storing and retrieving type information of the objects at runtime. This information can be used for safely typecasting objects, and to fetch and utilize the type information to set the flow of the program at runtime.

The RTTI requires the classes in use to be “polymorphic” in nature, which means that there should be at least one virtual function defined in it. The system is used with the help of dynamic_cast<> and the typeid operator.

The typeid operator is available under the “typeinfo” header and can be used to find out the class to which a particular object belongs to, at runtime. The value returned by the operator is implementation-defined and hence, can be different across compilers. Thus, for portability sake, the operator can be used in the following manner:

#include<iostream>
#include<typeinfo>

struct dummyBase
{virtual ~dummyBase(){}};

struct dummyDer: dummyBase{};

void check(dummyBase* a)
{
   if(typeid(*a)==typeid(dummyBase))
      std::cout<<"It is a dummyBase object\n";

   else if(typeid(*a)==typeid(dummyDer))
      std::cout<<"It is a dummyDer object\n";
}

int main()
{
   dummyDer d;
   dummyBase b;
   dummyBase*ptr;

   ptr=&d;
   check(ptr);

   ptr=&b;
   check(ptr);
}

If only the object information is required and no cast is to be done, then one must use the typeid operator and not the dynamic_cast because the former takes constant-time to return the value.

The dynamic_cast<> operator is what actually utilizes the RTTI system. The dynamic_cast<> is safe because if the cast is not possible, it sets the pointer to NULL instead of returning a bad pointer and in case of a reference, it throws the std::bad_cast exception. The cast knows about the hierarchy of the particular object that helps it do its work correctly and can be used to cast up, down or laterally.

For Example:

#include<iostream>

struct ITop
{
   virtual void funcTop()=0;
   virtual ~ITop(){}
};

struct ILeft: ITop
{
   void funcTop(){ std::cout<<"ILeft funcTop\n";}
   virtual void funcLeft()=0;
};

struct IRight: ITop
{
   void funcTop(){ std::cout<<"IRight funcTop\n";}
   virtual void funcRight()=0;
};

struct Left: ILeft
{
   void funcLeft(){ std::cout<<"Left heir\n";}
};

struct Right: IRight
{
   void funcRight(){ std::cout<<"Right heir\n";}
};

void Foo(ITop* elem)
{
   elem->funcTop();

   if(ILeft* ptrL = dynamic_cast<ILeft*>(elem))
      ptrL->funcLeft();
   else if(IRight* ptrR = dynamic_cast<IRight*>(elem))
      ptrR->funcRight();
}

int main()
{
   ITop* ptr[]={new Left, new Right};

   Foo(ptr[0]);
   Foo(ptr[1]);

   delete ptr[0];
   delete ptr[1];
}

In the above code, the function Foo() checks the type of ‘elem’ and finds out where does the object lie in the hierarchy and accordingly, invokes either the funcLeft() or the funcRight().

Here is one good use of RTTI.

The virtual mechanism, though used without the knowledge of the complete type of the object, works only on fully-constructed objects. But, in order to create an object, the user is required to provide the complete information about the object. Thus, it is not possible for a constructor to be virtual.

2. What is virtual destructor?

Consider a class “Base” that is inherited by another class “Derived” and there exists a pointer-to-base referring to a heap-allocated derived object, then a virtual destructor would be required in the base class for the proper clean-up of the object. If the destructor is not virtual, then the destructor for the derived sub-object won’t be called and hence, the resources will not be freed.

For Example:

#include<iostream>

struct Base
{
      Base(){std::cout<<"Base object constructed\n";}
      ~Base(){std::cout<<"Base object destructed\n";}
};

struct Derived: Base
{
      Derived(){std::cout<<"Derived object constructed\n";}
      ~Derived(){std::cout<<"Derived object destructed\n";}
};

int main()
{
      {
            Base b_Obj;
            Derived d_obj;
      }
      {
            Base *p_b = new Derived();
            delete p_b;
      }
}

In the above code, the b_obj and d_obj would be destructed properly but the object referred-to by the pointer p_b won’t be destructed properly until the base class’ destructor is made virtual.

This is because when p_b is delete-ed, it calls the destructor of the static type of the pointer, which is Base, instead of the Dynamic type.

Thus, whenever it is possible that your class might be inherited by another class, it is safe to make the destructor virtual.

3. What is Self-Assignment? Does it have any bugs/problems associated with it?

Assignment of an object to itself is known as self-assignment.

For example:

int func(int &x, int &y)
{
      x=x;   /* Self Assignment */

      x=y;   /* Self-Assignment, because x and y both refer to "data" [defined in main() ] */
}

int main()
{
      int data=10;
      fun(data, data);
}

One potential problem associated with self-assignment arises in the following code:

class dummy
{
      int n;
      int *ptr;

public:
      dummy() : ptr(new int){ *ptr = 0; }
      ~dummy() {delete ptr;}

      dummy& operator= (const dummy& D)
      {
            delete ptr; /* #1 */
            ptr= D.ptr; /* #2 */
      }

      int* operator*()
      {
            return ptr;
      }
};

int main()
{
      dummy mObj(10);
      mObj = mObj;
}

Here, Line #1, delete-s the pointer ptr, which is then invalidated. Line #2 assigns that freed memory back to ptr. If the pointer is now used, it will invoke Undefined Behavior.

To prevent this, the = operator should first check for self-assignment.

dummy& operator= (const dummy& D)
{
      if(*this==D)
            return *this;
      else
      {
            delete ptr;
            ptr = D.ptr;
            return *this;
      }
}

4. What do you mean by Shallow copy and Deep copy?

Shallow copy and Deep copy are two ways of copying an object.
Consider the following code

class Dummy
{
      string d_str;
      int* d_ptr;
public:
      Dummy(string xstr, int* dptr) : d_str(xstr), d_ptr(pstr) {}
      ~Dummy() { delete d_ptr;}
};

int main()
{
      Dummy Xobj("Test_Object", new int);
      {
            Dummy Yobj = Xobj;
      }
}

A shallow copy of an object copies it bit-by-bit. This is what happens in the implicitly-defined assignment operator and copy constructor.

In the above example, the Xobj will be copied bit-by-bit into Yobj. Here, the copy constructor of Xobj.d_str will be first invoked to copy its contents into Yobj.d_str and then the Xobj.d_ptr would be copied  into Yobj.d_str and Yobj.d_ptr. The copy constructor of std::string has been defined to perform a Deep copy but the Xobj.d_ptr would be shallow-copied which means that Xobj.d_ptr and Yobj.d_ptr will both point to the same memory location and any change to one pointer will cause a change to the other.

The main problem occurs when an object goes out of scope or a pointer element is freed/invalidated. In the above example, Yobj will go out of scope and the memory pointed would be freed, causing both Xobj.d_ptr and Yobj.d_ptr to be invalidated and, thus, the user is not allowed to use Xobj.d_ptr any further.

A deep copy of Xobj into Yobj would cause the member Yobj.d_ptr to get hold of a new memory location and the contents of the memory be same as of those referred by the member Xobj.d_ptr. Now, as the memory location referred by Xobj.d_ptr and that by Yobj.d_ptr are different, deletion/invalidation of the memory causes no trouble to Xobj.

5. What is the Placement new? Where would you use it? What are your responsibilities?

The Placement new operator is used in case you want the object to be placed at a particular pre-allocated memory.

For Example:

class test
{
      /* members and methods */
};

int main()
{
      char memory[sizeof(test)];
      char* position = memory;
      test* object = new(position) test;
}

Some situations where placement new can be used are :

1. When writing your memory allocation unit and you want memory to be allocated from only a pre-allocated section of memory.
2. Used when it is required that I/O devices be mapped to specific memory addresses.
3. To create a shared memory region (for Inter-process Communication)

There are a lot of other uses of placement new. Check here

When using placement new, the following points need to be kept in mind:

1. Don’t use placement new unless you really need it and it is important that the object be places at some particular location in memory
2. It is the programmer’s job to check that the memory being used has enough space for the object and the memory is aligned properly.
3. The programmer is responsible for destruction the placed object, i.e., the programmer needs to call the destructor explicitly.

These questions were handpicked by the author, who happens to be an active member in one of the largest C++ communities in Orkut which boasts to have over 146,000 members.

6. What are pure virtual functions? Give a real-world example for abstract class and pure virtual function?

A pure virtual function is a virtual function that doesn’t require a definition in the base class. A pure virtual function is defined by writing =0 after its signature. The definition can be provided if some default behavior or error-handling is required.

In some cases it’s not logical to instantiate an object of a class. In such cases, the concept of abstract classes can be made use of. To make a class abstract, the class needs to include at least one pure virtual function.

For Example:

Consider a class Employee that defines the generic behavior of different types of Employees that work in a company.

#include<iostream>
#include<string>

using std::string;

class Employee
{
      string name;
      string Emp_num;

protected:
      int Basic;
      float allowance;

public:
      Employee(string _name, string _num, int _base, float allow): name(_name), Emp_num(_num), Basic(_base), allowance(allow){}

      virtual ~Employee(){}

      virtual float salary()=0;
      int getBasic(){ return Basic; }
      std::string getName(){ return name; }
};

class Manager: public Employee
{

public:
      Manager(string name, string Emp_num, int Base): Employee(name, Emp_num, Base, 3.2){}

      Manager(string name, string Emp_num, int Base, float allow): Employee(name, Emp_num, Base, allow){}

      float salary()
      {
            float sal;

            /*Calculations for Manager's salary*/
            sal = Basic + (allowance/100)*Basic;
            return sal;
      }
};

class Executive: public Employee
{

public:
      Executive(string name, string Emp_num, int Base): Employee(name, Emp_num, Base, 1.2){}

      Executive(string name, string Emp_num, int Base, float allow): Employee(name, Emp_num, Base,allow){}

      float salary()
      {
            float sal;

            /*Calculations for Executive's salary*/
            sal = Basic + (allowance/100)*Basic;
            return sal;
      }
};

int main()
{
      Employee *Mgr= new Manager("Saurabh","M001", 50000);
      Employee *Exec = new Executive("Ajay","E002", 20000);

      std::cout<<"Manager's salaryt: "<<Mgr->salary();
      std::cout<<"nExecutive's salaryt: "<<Exec->salary();
}

Here, the Employee has been made an abstract class because every Employee needs to be one of Manager, Executive, Trainee, etc.. The existence of an Employee in itself doesn’t tell you where the Employee stands in the hierarchy.

7. What is a template?

Templates in C++, are a way to achieve generic nature in programming. By using templates, we can define functions and classes that show the same( or similar) behavior on different types.

For Example:

#include<iostream>

template<typename T>
void swap(T&amp;amp; obj1, T&amp;amp; obj2)
{
      T temp = obj1;
      obj1 = obj2;
      obj2 = temp;
}

int main()
{
      int val1=20, val2=50;
      std::cout<<"Before Swap:t";
      std::cout<<"val1 = "<<val1<<" val2 = "<<val2<<std::endl;
      swap(val1, val2);
      std::cout<<"After Swap:t";
      std::cout<<"val1 = "<<val1<<" val2 = "<<val2<<std::endl;
}

Note: Don’t use this swap(T&,T&) to swap container objects, because copying and assignment may cause heavy overheads. Instead, use the swap() function provided by the container itself.

For Example:

template<typename T>
class List
{
      struct Link{ T data; Link* next;};
      Link head;
public:
      void insert(T data) { /*Add new node*/ }
      void remove()       { /*Remove a node*/ }
      T fetch()             { /*Return first node data*/ }
};

Now, one can have a List of ints, List of chars, List of strings, etc..

8. What is the conversion operator?

The conversion operator is used to convert a user-defined type to some other type.

Consider a class smallInt that is used to store integers in range [0,5000]. Objects of such type would be constantly exposed to arithmetic operations.

To access the integer value of the object, we can

1. use accessor methods
2. use conversion operator

Using an accessor method again and again in an expression would invoke unnecessary invitations to explicit function calls and the code would become procedure-oriented rather than data-oriented.

Instead we can define a conversion operator that will fetch the integer value wrapped in the smallInt object whenever required.

#include<iostream>
#include<stdexcept>

class smallInt
{
      int value;
public:
      smallInt(): value(0){}

      smallInt(int x): value(x)
      {
            if(x>5000 || x<0)
                  throw std::out_of_range("smallInt Range: 0-5000");
      }

      operator int(){ return value;}
};

int main()
{
    try{
        smallInt obj500(500), obj33(33);
        std::cout<<obj500*obj33;
        smallInt object = obj500*obj33;        //throws exception
    }catch(std::out_of_range&amp;amp; e){std::cout<<"n"<<e.what();}
}

PS: out_of_range can be accessed using the header stdexcept

9. What are the different casts supported by C++?

C++ supports a variety of casts. They can be listed as :

1. C-style cast
   float myFloat=24.829;
   int myInt = (int)myFloat;
2. Function-style cast
   int myInt = int(myFloat);

   The above two casts are not reliable and should be used to cast between built-in types only.

3. static_cast < T > (f)
   These are less dangerous than the C-style casts. Should be used when an implicit conversion from T to F or vice-versa exists. This can be used to cast numeric types or for upcasting class objects.
   Also, these can be used to convert a base-class pointer to a derived-class pointer, but as it is done during compile-time, the dynamic type is not known. Hence this cast can invite trouble.

   Example 1:

   class base
   {
         /*Members*/
   };
   
   class derived: public base
   {
         /*Members*/
   };
   
   base* ptr_bb = new base;
   base* ptr_bd = new derived;
   
   /*Conversion 1*/
   derived* ptr_db = static_cast<derived*>(ptr_bb);
   
   /*Conversion 2*/
   derived* ptr_dd = static_cast<derived*>(ptr_bd);
   

   This would compile fine but during run-time it might cause problems because in Conversion 1, ptr_bb points to an object of its Base-type and not to its derived.
   Conversion 2 is safe because ptr_bd points to a derived object which can be well-handled using ptr_dd which is a pointer to derived type.

   Example 2:

   float myFloat = 24.222;
   int myInt = static_cast(myFloat);

4. dynamic_cast < T >(f)
   This cast is type-safe in nature. It’s used to downcast pointers and references to their base class safely. This cast is done at run-time and returns the correct sub-object if the cast was possible, else returns 0 and throws a bad_cast exception. It is required that there be at least one virtual function in the base class.

   For Example:

   base* ptr_b1 = new base;
   base* ptr_b2 = new derived;
   
   /* Conversion 1. ptr_d1 will be zero*/
   derived* ptr_d1 = dynamic_cast<derived*> ptr_b1;
   
   /* Conversion 2. ptr_d2 will be valid*/
   derived* ptr_d2 = dynamic_cast<derived*> ptr_b2;
   

5. reinterpret_cast < T >(f)
   This type of cast is a very rarely used cast, because the after-effect is implementation-defined,i.e., . It treats the pointers and references as incomplete types. The casted value obtained should be used only after casting back to its original type.
6. const_cast < T >(f)
   This cast is used to cast away the const-ness of objects or pointers. This should be used only when one is sure that the underlying object was not defined to be a const. If the underlying object was a const, it would invoke Undefined Behavior.

10. What is the auto_ptr? Why is it required?

The auto_ptr is a type declared in the <memory> header. It is used to get the basic Resource Acquisition is Initialization(RAII) features.

The RAII features are required to write an exception-free code. This is because if a function throws an exception, then stack unwinding takes place and it destroys the objects on the stack, but not those that are allocated dynamically.

Hence, we can create a type that will wrap the pointer and use accessor functions to access the memory. As the object would be on the stack, its destructor would be called during the stack unwinding and hence, the dynamically allocated memory is freed.

For Example:

#include<iostream>
#include<memory>

int main()
{
    std::auto_ptr<int> x(new int);
    std::cin>>*x;
    std::cout<<*x;
}

Read Part2 of C++ Medium Interview Questions

These questions were handpicked by the author, who happens to be an active member in one of the largest C++ communities in Orkut which boasts to have over 146,000 members.

1. What are the POD types?

In C++, a POD or a Plain-Old Data type is either a scalar type or a POD class.

Scalar types are those that represent a single value. The int, float, bool, etc are scalar types.

A POD class is one which has no user-defined constructor, no user-defined assignment operator and no non-static member which in itself is non-POD. It should have only public members, no base classes and no virtual functions.

2. What are the container classes supported by C++ ?

C++ supports a number of container classes, divided into 3 categories:

1. Sequence Containers:
   vector, deque and list.
2. Associative Containers:
   map, multimap, set, multiset and bitset
3. Adapters:
   stack, queue and priority_queue

3. What is the difference between delete and destructor in C++?

The delete operator is responsible for freeing the dynamically allocated memory while the destructor is responsible for cleaning up an object just before the memory is actually freed.

The delete operator is used on a pointer to free the memory dynamically allocated by the pointer. It is required to be called explicitly by the program, else there would be memory leaks. delete-ing an object leads to invocation of the destructor.

A destructor is invoked implicitly, when the scope of an object ends or when the dynamically allocated object is deleted, in all cases except when the allocation is done using placement new. The destructor performs the functions just opposite to the constructor. It is used to clean up the resources, before the object goes out of scope or the memory is de-allocated.

For Example:

#include<iostream>

class dummy
{
      int a;
public:
      dummy(): a(0)
      { std::cout<<"Default constructor\n"; }

      dummy(int x): a(x)
      { std::cout<<"Parametrized constructor\n";}

      ~dummy()
      { std::cout<<"Destructor\n";}
};

int main()
{

/*Allocates memory dynamically and then calls constructor*/
      dummy* ptr = new dummy;

/*New Block starts */
      {

/* Allocates memory on the stack and then calls constructor */
            dummy myObj(25);

      }
/*myObj out of scope. Destructor called*/

/*Object pointed by ptr is deleted and destructor called*/
    delete ptr;
}

If the statement “delete ptr;” is removed, the destructor for the object won’t be called and the memory would not be freed.

4. What is function overloading and operator overloading?

Overloading is a method of implementing Polymorphism in C++.

Function overloading is one where different functions with the same name are defined and which function is called depends upon the data type being passed.

For Example:
One may want functions to add different types of data.

int add(int a, int b){return a+b;}

double  add(double a, double b){ return a+b;}

Now a call, say add(4, 5) would invoke the add function taking two int arguments.

Operator overloading is a way to make the built-in operators work on the User-defined types. This makes the user-defined types to look like the built-in types and thus makes the code generic and realistic.

For Example:
A class Time can overload the + operator to add minutes and – operator to subtract minutes.

#include<iostream>

class Time{

      int hrs, min, sec;
public:
      Time()    {/*Assign System Time */}
      Time(int inHrs, int inMin=0, int inSec=0): hrs(inHrs), min(inMin), sec(inSec){}

      Time& operator+(int minutes)
      {addMinutes(minutes); return *this;}

      Time& operator-(int minutes)
      {subMinutes(minutes); return *this;}

      void addMinutes(int minutes) {/*Add Minutes*/}
      void addSeconds(int seconds) {/*Add seconds*/}
      void addHours(int hours) {/*Add hours*/}

      void subMinutes(int minutes) {/*Subtract Minutes*/}
      void subSeconds(int seconds) {/*Subtract seconds*/}
      void subHours(int hours) {/*Subtract hours*/}
};

int main()
{
      Time t1(12,20,13);        /* t1 has 12:20:13 */
      Time t2 = t1 + 50;        /* t2 has 13:10:13 */
}

5. What are virtual functions?

A virtual function in C++ can be used inside a class to implement dynamic polymorphism by overriding the methods of its direct or indirect base class.

It is used when the base class function can’t completely define the behavior of the object and hence, the control is handed over to the correct function which can handle it whenever possible. The calls to the correct function are bound during run-time.

For example:
Consider a class ‘Shape’ that represents geometric shape. Let Polygon and Circle inherit from this Shape class. Let there be two possible behaviors of Polygon and Circle, draw() and area().

The Shape class can’t define the functions, because both depend on the type of the Shape. The area of a circle is different from the area of a square. Hence, these functions are made virtual.

#include <iostream>
const float PI = 3.14;

class Shape
{
      public:
          virtual float area() { return -1;};

//Other functions
};

class Square: public Shape
{
      float edge;
public:
      Square(float side): edge(side){ }
      float area(){ return edge*edge; }

      //Other functions
};

class Circle: public Shape
{
      float radius;
public:
      Circle(float R) : radius(R) { }
      float area() { return PI * radius * radius; }

//Other functions
};

int main()
{
      Shape* myShape = new Circle(29);

      /* This will return Circle's area*/
      std::cout << "Area : " << myShape->area();
      delete myShape;

      /*Creates a Square with Side = 10 units*/
      myShape = new Square(10);

      /* This will return Square's area */
      std::cout << "Area : " << myShape->area();
      delete myShape;
}

Note: It would be a good design practice to make the Shape class abstract because a Shape in itself doesn’t make sense.

These questions were handpicked by the author, who happens to be an active member in one of the largest C++ communities in Orkut which boasts to have over 146,000 members.

6. What is polymorphism? Explain with an example?

Polymorphism is a way of providing a uniform interface with which different types of objects can interact and receive response based on the type itself. It can be said as “Same Work, Different Types”.

It is a common situation that objects of different types might have some common method, but depending on the type, the method needs to work differently.
For ex: All shapes have area, but each shape has a different way of calculating it.

In C++, polymorphism is implemented using

1. Function Overloading
2. Operator Overloading
3. Function Overriding (using virtual functions)

In function overloading and operator overloading, the function to be used is decided at the compile-time itself. But the binding of the call to the function in function overriding is done at the run-time.

For Example:

#include<iostream>

float area(float a)
{
      std::cout<<"(Circle)";
      return 3.14*a*a;
}

float area(float a, float b)
{
      std::cout<<"(Rectangle)";
      return a*b;
}

int main()
{
      std::cout<<area(15)<<"\n";
      std::cout<<area(10,12.50);
}

Decision regarding the function to be called is based upon the functions’ signatures, which include the function name and the arguments(number and type).

7. What is the use of the ‘volatile’ keyword?

The volatile keyword is a type-qualifier and is a signal to the compiler telling it

not to do any optimizations on the variable with this qualification.
that the state of the variable can change anytime and the changes in the state could be due to some external control.

A variable should be declared volatile if its value can change unexpectedly.

For Example:

A variable shall be made volatile if

1. It’s being shared between concurrent processes(threads).
2. Its value can be changed by some interrupt service routine.

For further reading on volatile keyword, see here.

8. What is Encapsulation?

Encapsulation can be defined as a process of binding the attributes of an object with the associated methods, and way of implementing data hiding.

Using this feature of the object-oriented approach, one can implement a class such that its instances satisfy the definition of an object, i.e., each object has its attributes and properties, depending upon the type, and that no object, without specific permissions, can have access to the methods/attributes of a different type.

For Example:

In the following, an object of type Cat can’t bark. Similarly, a Dog can’t meow !!

#include<iostream>
#include<string>

using std::string;

class Cat
{
      string Name;
      int Age;

public:
      Cat(string _name, int _age) : Name(_name), Age(_age){}
      void meow(){ std::cout<<"Meow Meow!!";}
};

class Dog
{
      string Name;
      int Age;

public:
      Dog(string _name, int _age) : Name(_name), Age(_age){}
      void bark(){ std::cout<<"Ruff Ruff!!";}
};

9. What are dangling pointers?

A pointer that doesn’t point to a valid memory location, i.e., it points to a storage that is no longer allocated is a dangling pointer.

For Example:

int main()
{
      int *p = new int;
      /*Some Processing on p*/
      delete p;
      // Now p is a dangling pointer
}

It’s very useful to assign a deleted pointer to 0(zero) or NULL after delete-ing.

10. What is the Constructor Initialization List?

Whenever you create an object in C++, the constructor is invoked. It is responsible for the initialization of the data members of the class and for calling its parent class’ constructor. The constructor initialization list is used for initializing the non-static data members of a class. The list follows the constructor signature after a single colon.

For Example:

class myClass
{
      int x;
      string data;
public:
      myClass() : x(0), data() {}
      myClass( int a, string inp) : x(a), data(inp) {}
};

Here, the default constructor initializes x to 0 and makes data an empty string and the parametrised constructor initializes x to a and data to inp.

The order of members in the initialization list doesn’t matter because the initialization is always done in the order in which the data members are declared in the class. Similarly, the order of invocation of the parent class constructor depends upon the order in which parent classes are mentioned in the derivation list.

For Example :

class base1
{
      int i;
public:
      base1() : i(0){}
      base1(int x) : i(x){}
};

class base2
{
      int j;
public:
      base2() : j(0){}
      base2(int x) : j(x){}
};

class der: public base1, public base2
{
      string data;
public:
      der(): data(), base1(), base2() {}
      der(int a, int b, string inp) : base2(b), data(inp), base1(a) {}
};

So, in the above initialization list for the class der, the order of initialization would be :
Invoke base1′s constructor
Invoke base2′s constructor
Initialize “data

Read Part2 of C++ Easy Interview Questions

These questions were handpicked by the author, who happens to be an active member in one of the largest C++ communities in Orkut which boasts to have over 146,000 members. We believe that you can’t get a better set of interview questions with the kind of quality of answers that you get here.

1. Is the usage of void main() a good practice?

No, the usage void main() is not a good coding practice.

The value returned from the main() is sent to the host environment or the parent process that calls your program. The parent might need to follow different paths depending on the success or failure of your program. Hence, one must always return a value from the program that returns its status back to the callee.

Moreover, the C++ standard specifies only two portable versions of the main() function – one that takes no parameters and the other that takes two parameters( an int and a array of pointer to char ), both of which return an int.

The versions are :

int main() {}

int main(int argc, char* argv[]){}

Any other signature of main() would be implementation dependent. Which means that the code that compiles on your compiler might not work on other compilers.

2. What is an object?

An Object, in the object-oriented terminology, is a real-world entity which has attributes and methods. An object is distinguished from another object by its identity. Every object has a type. Speaking in the language of C++, an object is an instance of a class.

In simple English, object is a concrete physical thing whose appearance and behavior can be described in words.

A simple example of an object would be my Dog, Lyca. In object oriented lingo, Dog is a Class and Lyca is an object of class Dog.

3. Why is the size of an object of an empty class not zero?

The size of an object of an empty class is not zero so that two objects of that class have different storage locations. If the size had been zero, then the new operator would have returned the pointer to the same location always.

For Example:

#include<iostream>

class EmptyClass{};

int main()
{
      EmptyClass *object1 = new EmptyClass();
      EmptyClass *object2 = new EmptyClass();

     if(object1 == object2)
             std::cout<<"Oops! This should not happen";
      else
            std::cout<<"I love hamburgers!!";
}

If the size of the object of EmptyClass is zero, then object1 and object2 would have pointed to the same memory location.

Moreover, if the EmptyClass is used as a base class to some Derived class, then it is not necessary to provide a separate byte to the base sub-object of the Derived class’ object. This means that the compiler can do some optimization so that the address of the derived class object is same as that of the first member of the derived sub-object.

For Example:

#include<iostream>

class EmptyBase{};

class EmptyDerived: public EmptyBase
{
      public:
            int member;
};

int main()
{
      EmptyDerived der;

      int EmptyDerived::*member_ptr = &EmptyDerived::member;

      void* ptr_der = static_cast<void*>(&der);
      void* ptr_member= static_cast<void*>(&(der.*member_ptr));

      if(ptr_der == ptr_member)
            std::cout<<"Optimized compiler";
      else
            std::cout<<"Still, no problem";
}

4. What is the difference between a C++ class and a C++ structure?

There is actually no difference between a class and structure in C++, except that the members of a struct are public by default and those of a class are private by default.

For Example:

class UselessClass
{
      int x;
public:
      UselessClass(): x(0){}
      UselessClass(int a): x(a){}
};

struct UselessStruct
{
      UselessStruct(): x(0){}
      UselessStruct(int a): x(a){}
private:
      int x;
};

Both of these are functionally equivalent.

5. What are namespaces?

Namespaces are a way to group your classes, objects and functions under a single roof. It’s a way of defining a new scope.

Consider a situation when you are required to make use of a lot of external libraries in a C++ project. Also, assume that a lot of classes have been written by yourself. It may happen that the name of a class or a function you write clashes with that in an external library. This would lead to name collisions and ambivalence to the compiler.

A solution to this problem is to change the name of your class, which is a not a great option. How can external libraries steal your ‘right to name C++ codes’.

A cleaner way to solve this problem is to put your entities in a namespace.

For Example:

#include<iostream>
#include "Glib.h"

/* Glib is some Graphics Library with namespace Glib and class Circle. */

/* Your own Graphics namespace */
namespace stdShape
{
      class Circle
      {
            int centerX, centerY, Radius;
      public:
            Circle(int x, int y, int rad) : centerX(x), centerY(y), Radius(rad){}

            void draw();
            float area();
      };

      void Circle::draw()
      { /*Draw the shape on the screen*/
        std::cout<<"Drawing stdShape Circle";
      }

      float Circle::area()
      { /*Return the area of given Shape*/
         return 3.141*Radius*Radius;
      }
}

int main()
{
/* Creating a Circle at (2,5) with radius 10 */
    stdShape::Circle myCircle(2,5,10);

    myCircle.draw();
    std::cout<<"Area of myShape : "<<myCircle.area();

/* Creating a Circle using GLib library */
    GLib::Circle GShape(10,12,6);
    GShape.draw();
}

Generally, the namespace and its inner declarations are written in a header file and the definitions for its elements are given in a separate cpp file. Then, the main C++ source file includes the header file.
This means, we would have 3 files for this code:

File1 (stdShape.h) that gives the declarations for the namespace and class
File2 (stdShape.cpp) that includes stdShape.h and defines the class
File3 (main.cpp) that incudes stdShape.h and Glib.h and defines the main() function

In near future, medium and hard level C++ questions would be added. Subscribe via Email to be sure you don’t miss any updates.