Programming using C++
Interview Questions with Answers

21. What is a constructor? Types of constructors in C++?

Answer:

A constructor is a special member function of a class that is automatically invoked when an object is created. It initializes the object.

 Characteristics:

• Has the same name as the class
• No return type
• Can be overloaded

 Types of Constructors:

1. Default Constructor – Takes no parameters
2. Parameterized Constructor – Accepts arguments
3. Copy Constructor – Initializes an object using another object
4. Dynamic Constructor – Allocates memory dynamically (uses new)
5. Constructor with Initialization List

22. What is a copy constructor?

Answer:

A copy constructor is used to initialize a new object as a copy of an existing object. 

Syntax:

ClassName(const ClassName &obj);

Example:

class Student {
    int id;
public:
    Student(int x) { id = x; }
    Student(const Student &s) { id = s.id; }
};

• If not defined explicitly, C++ provides a default copy constructor.
• Required when objects have pointers or dynamic memory (to avoid shallow copies).

23. What is a destructor? When is it called?

Answer:

A destructor is a special member function that is automatically called when an object goes out of scope or is explicitly deleted. It is used to free resources like dynamic memory.

Syntax:

~ClassName();

Characteristics:

• No parameters, no return type.
• Cannot be overloaded.
• Only one destructor per class.

Example:

class A {
public:
    ~A() {
        cout << "Destructor called\n";
    }
};

24. What is the difference between a constructor and a method?

Answer:

25. Can constructors be virtual? Why or why not?

Answer:

No, constructors cannot be virtual in C++.

Reason:

• Constructors are invoked to create objects.
• Virtual functions require a vtable, which is set up after the constructor runs.
• Making constructor virtual would require vtable access before it’s constructed — which is not possible.

However, destructors can and should be virtual in polymorphic base classes.

26. Can a constructor be overloaded?

Answer:

Yes, constructors can be overloaded in C++.

Meaning:

A class can have multiple constructors with different parameter lists to allow various ways of initialization.

Example:

class Person {
public:
    Person() { }
    Person(string name) { }
    Person(string name, int age) { }
};

Enables constructor flexibility.

27. What is a default constructor?

Answer:

A default constructor is a constructor that takes no parameters (or all parameters have default values).

Example:

class Test {
public:
    Test() {
        cout << "Default constructor called\n";
    }
};

Note:

• If no constructor is provided, C++ automatically generates a default constructor.
• If any other constructor is defined, the default is not provided automatically unless explicitly defined.

28. What is the difference between shallow copy and deep copy?

Answer:

Example:

class A {
    int* ptr;

public:

    A(int x) { ptr = new int(x); }
    // Deep copy constructor
    A(const A &obj) {
        ptr = new int(*obj.ptr);
    }
    ~A() { delete ptr; }
};

29. What happens if you don’t define a destructor?

Answer:

If you don’t define a destructor:

• C++ provides a default destructor.
• For classes that do not manage resources manually, this is fine.
• BUT if your class allocates memory (e.g., with new), not defining a destructor leads to memory leaks.

Always define a destructor when your class allocates dynamic memory or resources (file handles, sockets, etc.).

30. What is constructor initialization list?

Answer:

A constructor initialization list is a more efficient way to initialize data members and base classes in C++.

 Syntax:

class Student {
    int id;
    string name;
public:
    Student(int i, string n) : id(i), name(n) { }
};

Benefits:

• Initializes const and reference members (which must be initialized once).
• Efficient for initializing base classes and large objects.
• Avoids default constructor followed by assignment.

31. What are the types of inheritance in C++?

Answer:

C++ supports five types of inheritance:

1. Single Inheritance – One base and one derived class.
2. Multiple Inheritance – A class inherits from more than one base class.
3. Multilevel Inheritance – Class derived from another derived class.
4. Hierarchical Inheritance – Multiple classes inherit from a single base class.
5. Hybrid Inheritance – Combination of any of the above, often leads to diamond problem.

32.What is multiple inheritance?

Answer:

Multiple Inheritance is when a derived class inherits from more than one base class.

Syntax:

class A { };
class B { };
class C : public A, public B { };  // C inherits from A and B

It allows combining features from multiple sources, but may cause ambiguity (like same function in both A and B).

33. How is ambiguity resolved in multiple inheritance?

Answer:

Ambiguity occurs when two base classes have members with the same name.

Resolved using scope resolution operator :::

class A {

public:

    void display() { cout << "A\n"; }
};
class B {

public:

    void display() { cout << "B\n"; }
};
class C : public A, public B {

public:

    void show() {
        A::display();  // Resolving ambiguity
        B::display();
    }
};

34. What is the diamond problem in C++?

Answer:

It occurs in multiple inheritance when two base classes inherit from the same grandparent, and a derived class inherits from both, causing duplicate copies of the grandparent.

Example:

    A
   / \
  B   C
   \ /
    D

• Class D gets two copies of class A (via B and C).
• Leads to ambiguity (e.g., A::display() – which one?).

35. How does virtual inheritance solve the diamond problem?

Answer:

Using virtual inheritance, we tell the compiler to share the base class between multiple paths, avoiding duplication. 

Example:

class A { public: void show() { cout << "A\n"; } };
class B : virtual public A { };
class C : virtual public A { };
class D : public B, public C { };

Now, class D has only one copy of class A, avoiding ambiguity.

36. What is the difference between virtual and pure virtual functions?

Answer:

Example:

class A {

public:

    virtual void show() { cout << "A\n"; }           // Virtual
    virtual void draw() = 0;                         // Pure Virtual
};

37. What is an abstract class?

Answer:

An abstract class is a class that contains at least one pure virtual function. It cannot be instantiated, and is meant to be a base class.

Example:

class Shape {

public:

    virtual void draw() = 0;  // Pure virtual function

};

Used to define interfaces and polymorphic behavior in OOP.

38. What is function overriding?

Answer:

Function Overriding allows a derived class to provide a specific implementation of a method that is already defined in the base class.

Rules:

• Must have same name, parameters, and return type.
• Base class function should be virtual.
• Uses runtime polymorphism.

Example:

class Animal {

public:

    virtual void sound() { cout << "Animal sound\n"; }
};
class Dog : public Animal {

public:

    void sound() override { cout << "Dog barks\n"; }
};

39. What is a virtual table (vtable)?

Answer:

A vtable is a hidden lookup table created by the compiler for classes with virtual functions.

• Contains addresses of virtual functions.
• Every object with virtual functions contains a hidden pointer to its class’s vtable.
• Enables dynamic dispatch at runtime.

40. What is dynamic dispatch?

Answer:

Dynamic dispatch is the process by which a function call is resolved at runtime, based on the actual type of the object, not the pointer type.

 Enabled by:

• Virtual functions
• Vtable mechanism

Example:

Animal* a = new Dog();
a->sound();  // Calls Dog's sound() due to dynamic dispatch

Enables runtime polymorphism and flexibility in designing extensible applications.