Q: What is inheritance in C++?
A: Inheritance is a fundamental concept in object-oriented programming that allows you to define a new class (derived class) based on an existing class (base class). The derived class inherits the properties and behaviors of the base class, allowing code reuse and the creation of class hierarchies.
Example:
class Shape {
public:
void setColor(string color) {
this->color = color;
}
void draw() {
cout << "Drawing a shape." << endl;
}
private:
string color;
};
class Circle : public Shape {
public:
void draw() {
cout << "Drawing a circle." << endl;
}
};
int main() {
Circle circle;
circle.setColor("Red");
circle.draw();
return 0;
}
In this example, Circle is a derived class that inherits from the Shape base class. The derived class overrides the draw function to provide a specialized implementation for circles.
Q: What are the access specifiers used in inheritance?
A: In C++, you can specify the access level for the inherited members using access specifiers: public, protected, or private. The default access specifier for inheritance is private.
Example:
class Base {
public:
int publicMember;
protected:
int protectedMember;
private:
int privateMember;
};
class Derived : public Base {
// publicMember is still accessible as public
// protectedMember is still accessible as protected
// privateMember is not accessible from derived class
};
int main() {
Derived d;
d.publicMember = 1; // Accessible as public
d.protectedMember = 2; // Accessible as protected
// d.privateMember = 3; // Not accessible
return 0;
}
In this example, the publicMember and protectedMember of the base class are accessible in the derived class based on their access specifiers.
Q: What is the order of constructor and destructor invocation in inheritance?
A: In C++, when creating an object of a derived class, the base class constructor is invoked before the derived class constructor, and the destructor order is the reverse.
Example:
class Base {
public:
Base() {
cout << "Base constructor called." << endl;
}
~Base() {
cout << "Base destructor called." << endl;
}
};
class Derived : public Base {
public:
Derived() {
cout << "Derived constructor called." << endl;
}
~Derived() {
cout << "Derived destructor called." << endl;
}
};
int main() {
Derived d; // Output: Base constructor called. Derived constructor called. Derived destructor called. Base destructor called.
return 0;
}
In this example, the base class constructor is invoked first, followed by the derived class constructor. During object destruction, the derived class destructor is called first, followed by the base class destructor.
Important Interview Questions and Answers on C++ Inheritance
Q: What is inheritance in C++?
Inheritance is a mechanism in C++ that allows a class to inherit properties (data members and member functions) from another class. The class that is inherited from is called the base class, and the class that inherits is called the derived class.
Example:
class BaseClass {
public:
void display() {
cout << "Base Class" << endl;
}
};
class DerivedClass : public BaseClass {
};
int main() {
DerivedClass obj;
obj.display(); // Output: Base Class
return 0;
}
Q: What are the types of inheritance in C++?
In C++, inheritance can be of the following types:
- Single inheritance: A derived class inherits from a single base class.
- Multiple inheritance: A derived class inherits from multiple base classes.
- Multilevel inheritance: A derived class becomes the base class for another derived class.
- Hierarchical inheritance: Multiple derived classes inherit from a single base class.
- Hybrid inheritance: Combination of multiple inheritance and single inheritance.
Q: How is access control specified in inheritance in C++?
In C++, access control in inheritance is specified using access specifiers:
- Public inheritance: Public members of the base class become public members of the derived class, protected members become protected, and private members are inaccessible.
- Protected inheritance: Public and protected members of the base class become protected members of the derived class, private members are inaccessible.
- Private inheritance: Public and protected members of the base class become private members of the derived class, private members are inaccessible.
Q: What is function overriding in inheritance in C++?
Function overriding occurs when a derived class defines a function that is already present in its base class. The derived class provides a different implementation of the function. It allows polymorphic behavior.
Example:
class BaseClass {
public:
virtual void display() {
cout << "Base Class" << endl;
}
};
class DerivedClass : public BaseClass {
public:
void display() {
cout << "Derived Class" << endl;
}
};
int main() {
DerivedClass obj;
obj.display(); // Output: Derived Class
BaseClass* basePtr = &obj;
basePtr->display(); // Output: Derived Class (Polymorphism)
return 0;
}
Q: What is the difference between function overloading and function overriding in C++?
- Function overloading: It allows multiple functions with the same name but different parameters in the same class. The functions are distinguished by their parameter types or the number of parameters.
- Function overriding: It occurs when a derived class defines a function that is already present in its base class. The function signatures must be the same in the base and derived class for overriding.
Q: What is an abstract class in C++?
An abstract class is a class that cannot be instantiated and is typically used as a base class. It contains one or more pure virtual functions, making it an incomplete class. Derived classes must implement these pure virtual functions to become concrete classes.
Example:
class AbstractClass {
public:
virtual void display() = 0; // Pure virtual function
};
class ConcreteClass : public AbstractClass {
public:
void display() {
cout << "Concrete Class" << endl;
}
};
int main() {
ConcreteClass obj;
obj.display(); // Output: Concrete Class
return 0;
}
