This post is a part of an ongoing series of C++ Interview Questions. This is Second part of the two parts of C++ interview questions with medium difficulty.

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;
}

This post is a part of an ongoing series of C++ Interview Questions. This is First part of the two parts of C++ interview questions. Each part consists of 5 questions along with detailed answers. What’s common in all the questions in this set is that the level of difficulty is Medium.

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.