1. Why don’t we have virtual constructors?

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.

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 one 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 Easy.

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.