Tag: OOPs in C++

  • Inheritance in C++

    Learn Inheritance in C++ with simple examples, syntax, types, and access specifiers. A complete beginner to advanced guide for interviews and exams.

    Inheritance in C++ is an Object-Oriented Programming (OOP) concept where one class (called the derived class) acquires the properties and behavior (variables and functions) of another class (called the base class).

    In simple terms:
    Inheritance allows you to reuse existing code and build new features on top of it.

    Basic Syntax

    
    class BaseClass {
    // data members and member functions
    };
    
    class DerivedClass : access_specifier BaseClass {
    // additional members of derived class
    };

    Example :

    class BaseClass {
    public:
        int a;
    
        void display() {
            cout << "This is base class" << endl;
        }
    };
    
    class DerivedClass : public BaseClass {
    public:
        void show() {
            cout << "This is derived class" << endl;
        }
    };
    

    Example Program

    #include <iostream>
    using namespace std;
    
    class Animal {
    public:
        void eat() {
            cout << "Animal eats" << endl;
        }
    };
    
    class Dog : public Animal {
    public:
        void bark() {
            cout << "Dog barks" << endl;
        }
    };
    
    int main() {
        Dog d;
        d.eat();   // inherited from Animal
        d.bark();  // own function
        return 0;
    }
    

    Output:

    Animal eats
    Dog barks
    

    How Inheritance Works in C++

    1.Base Class is Created

    The base class contains common properties and functions.

    class Animal {
    public:
        void eat() {
            cout << "Animal eats" << endl;
        }
    };
    

    2.Derived Class Inherits Base Class

    The derived class uses : to inherit from the base class.

    class Dog : public Animal {
    public:
        void bark() {
            cout << "Dog barks" << endl;
        }
    };
    

    3.Object of Derived Class is Created

    When you create an object of the derived class, it can access:

    • Its own methods
    • Inherited methods from base class
    int main() {
        Dog d;
        d.eat();   // inherited function
        d.bark();  // own function
    }
    

    Internal Working of Inheritance

    Memory Sharing

    • The derived class object contains base class data + its own data
    • No duplication of code

    Conceptually:

    Dog object = Animal properties + Dog properties
    

    Function Access

    • Derived class can directly use public and protected members
    • Cannot access private members of base class directly

    Constructor Execution Order

    When object is created:

    1. Base class constructor runs first
    2. Derived class constructor runs next
    class A {
    public:
        A() {
            cout << "Base Constructor" << endl;
        }
    };
    
    class B : public A {
    public:
        B() {
            cout << "Derived Constructor" << endl;
        }
    };
    

    Output:

    Base Constructor
    Derived Constructor
    

    Destructor Order (Reverse)

    When object is destroyed:

    1. Derived class destructor runs
    2. Base class destructor runs

    Function Overriding

    Derived class can override base class function

    class A {
    public:
        void show() {
            cout << "Base";
        }
    };
    
    class B : public A {
    public:
        void show() {
            cout << "Derived";
        }
    };
    

    Access Specifiers in C++ Inheritance

    In inheritance, access specifiers define how the base class members are accessible in the derived class.

    Types of Access Specifiers

    public

    • Accessible everywhere
    • Can be used inside and outside the class

    protected

    • Accessible within the class and derived class
    • Not accessible outside

    private

    • Accessible only within the same class
    • Not accessible in derived class directly

    Syntax with Access Specifier

    class DerivedClass : access_specifier BaseClass {
        // code
    };
    

    Example:

    class B : public A
    

    How Access Specifiers Work in Inheritance

    Inheritance TypeBase public →Base protected →Base private →
    publicpublicprotected❌ not accessible
    protectedprotectedprotected❌ not accessible
    privateprivateprivate❌ not accessible

    Example Code

    #include <iostream>
    using namespace std;
    
    class A {
    public:
        int x = 10;
    
    protected:
        int y = 20;
    
    private:
        int z = 30;
    };
    
    class B : public A {
    public:
        void show() {
            cout << x << endl; // ✅ public → accessible
            cout << y << endl; // ✅ protected → accessible
            // cout << z; ❌ private → not accessible
        }
    };
    
    int main() {
        B obj;
        obj.show();
        cout << obj.x; // ✅ public accessible outside
        // cout << obj.y; ❌ not accessible outside
    }
    

    Key Points

    public → accessible everywhere
    protected → accessible in child class only
    private → not accessible in child class

    Default inheritance:

    • class → private inheritance
    • struct → public inheritance

    Real-Life Working Example

    Think of:

    • Parent Class: Vehicle
    • Child Class: Car

    Car automatically gets:

    • speed
    • engine

    But also adds:

    • air conditioning
    • music system

    Why Inheritance is Used in C++

    Benefits

    • Code reusability
    • Reduces duplication
    • Easy maintenance
    • Supports polymorphism
    • Improves readability

    Important Points

    • Inheritance uses : operator
    • Base class constructor executes first
    • Private members are not directly accessible
    • Supports multiple types (single, multiple, multilevel, etc.)
    • Used for “is-a” relationship (Dog is an Animal)

    What is the use of : in C++ Inheritance?

    In C++, the colon : is used to specify inheritance.

    It tells the compiler that:

    “This class is inheriting from another class.”

    Basic Syntax

    class DerivedClass : public BaseClass {
    };
    

    Here:

    • : → means inherit from
    • public → access specifier
    • BaseClass → parent class

    How : Works

    When you write:

    class B : public A {
    };
    

    It means:

    • Class B gets properties and functions of class A
    • B becomes child (derived class)
    • A becomes parent (base class)

    Example

    #include <iostream>
    using namespace std;
    
    class A {
    public:
        void show() {
            cout << "Base class" << endl;
        }
    };
    
    class B : public A {
    };
    
    int main() {
        B obj;
        obj.show();  // inherited using :
    }
    

    Without : → inheritance will NOT happen

    Without : (No Inheritance)

    class B {
    };
    

    Now:

    • B has no relation with A
    • Cannot access A’s functions

    Real Meaning of :

    Think of it like:

    : = “is derived from”
    : = “inherits from”

    Important Uses of :

    1. To inherit a class

    class Child : public Parent

    2. Multiple inheritance

    class C : public A, public B

    3. Access control during inheritance

    class B : private A

    Types of Inheritance in C++

    1. Single Inheritance

    One base class → One derived class

    class A {};
    class B : public A {};

    2. Multiple Inheritance

    One derived class inherits from multiple base classes

    class A {};
    class B {};
    class C : public A, public B {};

    3. Multilevel Inheritance

    Chain of inheritance

    class A {};
    class B : public A {};
    class C : public B {};

    4. Hierarchical Inheritance

    One base class → multiple derived classes

    class A {};
    class B : public A {};
    class C : public A {};

    5. Hybrid Inheritance

    Combination of multiple types (complex structure)

    Access Specifiers in Inheritance

    Inheritance TypePublic MembersProtected MembersPrivate Members
    publicpublicprotectednot accessible
    protectedprotectedprotectednot accessible
    privateprivateprivatenot accessible

    Example:

    class A {
    protected:
        int x;
    };
    
    class B : public A {
    public:
        void set() {
            x = 10; // accessible
        }
    };

    Key Concepts

    1. Code Reusability

    Reuse existing class code → reduces redundancy

    2. Method Overriding

    Derived class can redefine base class function

    class A {
    public:
        void show() {
            cout << "A";
        }
    };
    
    class B : public A {
    public:
        void show() {
            cout << "B";
        }
    };
    

    3. Constructor in Inheritance

    Base class constructor runs first

    class A {
    public:
        A() {
            cout << "Base constructor" << endl;
        }
    };
    
    class B : public A {
    public:
        B() {
            cout << "Derived constructor" << endl;
        }
    };
    

    4. Destructor Order

    Destructor runs in reverse order

    5. protected Keyword

    Allows access in derived classes but not outside

    6. super concept in C++

    C++ uses base class name instead of super

    class B : public A {
    public:
        void show() {
            A::show(); // calling base class function
        }
    };
    

    Advantages of Inheritance

    • ✔ Code reuse
    • ✔ Easy maintenance
    • ✔ Extensibility
    • ✔ Improves readability
    • ✔ Supports polymorphism

    Disadvantages

    • ❌ Tight coupling between classes
    • ❌ Can increase complexity
    • ❌ Improper use leads to errors

    Real-Life Example

    Think of:

    • Vehicle (Base Class)
    • Car, Bike (Derived Classes)

    All share common features like speed, engine, but also have unique features.

    Interview Questions

    1. What is inheritance in C++?
    2. Difference between inheritance and polymorphism?
    3. Types of inheritance?
    4. What is multiple inheritance?
    5. What is diamond problem?
    6. Difference between public, private, protected inheritance?
    7. Constructor order in inheritance?
    8. What is virtual inheritance?

    Summary

    Inheritance is a powerful feature in C++ that allows one class to inherit properties and behavior from another class, making code reusable, scalable, and easier to manage.

    Frequently Asked Questions (FAQs) on Inheritance in C++

    1️⃣ What is inheritance in C++?

    Inheritance is an OOP concept where a derived class acquires properties and functions of a base class.

    2️⃣ Why is inheritance used in C++?

    It is used for:

    • Code reusability
    • Reducing duplication
    • Easy maintenance
    • Extending existing functionality

    3️⃣ What is a base class and derived class?

    • Base class → Parent class
    • Derived class → Child class that inherits from base class

    4️⃣ What does : mean in inheritance?

    The : operator is used to define inheritance between classes.

    5️⃣ What are the types of inheritance in C++?

    • Single
    • Multiple
    • Multilevel
    • Hierarchical
    • Hybrid

    6️⃣ What is single inheritance?

    One derived class inherits from one base class.

    7️⃣ What is multiple inheritance?

    A derived class inherits from more than one base class.

    8️⃣ What is multilevel inheritance?

    A class is derived from another derived class (chain structure).

    9️⃣ What is hierarchical inheritance?

    Multiple classes inherit from the same base class.

    🔟 What is hybrid inheritance?

    Combination of multiple inheritance types.

    1️⃣1️⃣ What are access specifiers in inheritance?

    They control visibility of base class members:

    • public
    • protected
    • private

    1️⃣2️⃣ Can private members be inherited?

    Yes, but they are not directly accessible in derived class.

    1️⃣3️⃣ What is function overriding?

    When a derived class provides its own implementation of a base class function.

    1️⃣4️⃣ What is the order of constructor execution?

    • Base class constructor executes first
    • Then derived class constructor

    1️⃣5️⃣ What is the diamond problem?

    It occurs in multiple inheritance when a class inherits from two classes that have a common base class, causing ambiguity.

    Solution: Virtual inheritance

    For detailed understanding of Platform Devices and Drivers on Linux, refer to the Linux documentation on Platform Devices and Drivers .

  • Abstract Class and Interface in Cpp | Master Beginner-Friendly Guide 2026

    When you’re learning object-oriented programming in C++, two important concepts you’ll come across are Abstract Class and Interface in Cpp. These might sound a bit technical at first, but don’t worry — we’ll break everything down in a simple way.

    Are you new to object-oriented programming and trying to understand the difference between an Abstract Class and Interface in Cpp? This beginner-friendly guide on Abstract Class and Interface in C++ is exactly what you need! In this detailed article, we explain what abstract classes are, how pure virtual functions work, and how C++ uses abstract classes to simulate interface behavior.

    You’ll learn:

    • The definition and purpose of abstract classes in C++
    • How to declare and use pure virtual functions
    • The concept of interfaces in C++ and how to implement them
    • Key differences between abstract classes and interfaces
    • Real-world examples and code snippets for hands-on learning

    Whether you’re a student, a programming beginner, or someone preparing for C++ interviews, this comprehensive explanation of Abstract Class and Interface in C++ will strengthen your understanding and help you write clean, modular, and reusable code.

    Abstract Class and Interface in Cpp

    What is an Abstract Class?

    An abstract class is a class that cannot be directly used to create objects. It’s like a blueprint that other classes must follow.

    It is mainly used when:

    • You want to define a common structure or behavior for all derived classes.
    • You want to force derived classes to implement some specific functions.

    How to define an abstract class?

    In C++, a class becomes abstract if it has at least one pure virtual function.

    class Animal {
    public:
        virtual void makeSound() = 0; // Pure virtual function
    };
    

    What is a Pure Virtual Function?

    A pure virtual function is a function that has no body in the base class and must be overridden in derived classes.

    Syntax:

    virtual returnType functionName() = 0;
    

    Example of Abstract Class:

    #include <iostream>
    using namespace std;
    
    class Animal {
    public:
        virtual void makeSound() = 0;  // pure virtual function
    };
    
    class Dog : public Animal {
    public:
        void makeSound() {
            cout << "Woof!" << endl;
        }
    };
    
    int main() {
        Dog d;
        d.makeSound();  // Output: Woof!
    }
    

    🔸 You can’t create an object of Animal because it’s an abstract class.
    🔸 You must override makeSound() in the derived class.

    What is an Interface?

    In C++, interface is not a keyword like in Java or C#. But we can achieve interface-like behavior using abstract classes.

    An interface:

    • Only contains pure virtual functions.
    • Doesn’t have any data members or function definitions.

    Example of Interface in C++:

    class Printable {
    public:
        virtual void print() = 0;  // pure virtual function
    };
    

    Any class that implements Printable must define the print() function.

    Full Example of Interface:

    #include <iostream>
    using namespace std;
    
    class Printable {
    public:
        virtual void print() = 0;
    };
    
    class Document : public Printable {
    public:
        void print() {
            cout << "Printing Document..." << endl;
        }
    };
    
    int main() {
        Document doc;
        doc.print();  // Output: Printing Document...
    }
    

    Key Differences: Abstract Class and Interface in cpp

    FeatureAbstract ClassInterface-like (in C++)
    Can have data members?YesNo
    Can have function body?Yes (non-pure virtual functions)No (only pure virtual functions)
    Can have constructors?YesNo (interfaces don’t need them)
    Used forShared code + enforcing rulesOnly enforcing rules (contract)

    When to Use What?

    • Use abstract class when you want to share code and behavior among related classes.
    • Use an interface-style class when you want to define a contract (a set of rules that must be followed) without any implementation.

    Summary of Abstract Class and Interface in cpp

    • Abstract class = class with at least one pure virtual function.
    • You can’t create objects of abstract classes.
    • Interfaces in C++ are implemented using abstract classes with only pure virtual functions.
    • Abstract classes can have both complete and incomplete functions; interfaces only have incomplete ones.

    Frequently Asked Questions (FAQ) – Abstract Class and Interface in cpp

    Q1: What is an abstract class in C++?
    A: An abstract class in C++ is a class that contains at least one pure virtual function. It cannot be used to create objects directly and is meant to be inherited by other classes that implement its pure virtual functions.

    Q2: What is a pure virtual function?
    A: A pure virtual function is a function declared in a base class with no definition. It uses the = 0 syntax and must be overridden by derived classes. Example:

    virtual void speak() = 0;
    

    Q3: Can we create an object of an abstract class in C++?
    A: No, you cannot create an object of an abstract class. You must inherit it in a derived class and implement all pure virtual functions before creating an object.

    Q4: What is an interface in C++?
    A: C++ does not have a built-in interface keyword like Java, but you can create interface-like behavior using an abstract class that contains only pure virtual functions and no data members.

    Q5: What is the difference between an abstract class and an interface in C++?
    A:

    • An abstract class can have both pure and non-pure (regular) member functions and can include data members.
    • An interface (in C++ terms) contains only pure virtual functions and no data or implementation.

    Q6: Can an abstract class have constructors in C++?
    A: Yes, abstract classes can have constructors. However, since you can’t create an object of an abstract class, the constructor is only called when a derived class is instantiated.

    Q7: Can a class implement multiple interfaces in C++?
    A: Yes, C++ supports multiple inheritance, so a class can inherit from multiple abstract classes (interfaces), allowing it to implement multiple sets of behaviors.

    Q8: When should I use an abstract class vs. an interface in C++?
    A:

    • Use an abstract class when you want to provide default/shared implementation along with rules.
    • Use an interface-style abstract class when you only want to enforce certain function definitions (pure contract).

    Q9: Can an abstract class have a destructor in C++?
    A: Yes, and it’s good practice to declare the destructor as virtual in an abstract class to ensure proper cleanup when deleting derived objects.

    Q10: Is it possible to inherit an abstract class without implementing all pure virtual functions?
    A: Yes, but then the derived class also becomes abstract. To make it concrete (instantiable), all pure virtual functions must be implemented.

  • Master 25 OOPs Interview Questions for Embedded Software Engineers (2026)

    25 OOPs Interview Questions : Are you preparing for your next Embedded Software Engineer interview? A strong foundation in Object-Oriented Programming (OOPs) is critical, especially when working in C++ for embedded systems. In this article, we will explore 25 frequently asked OOPs interview questions, each explained in-depth with examples tailored for embedded systems. These questions are crafted to help you crack interviews at companies like Bosch, Continental, KPIT, Qualcomm, and more.

    25 OOPs Interview Questions

    Why OOPs in Embedded Software?

    Object-Oriented Programming helps embedded developers to:

    • Organize complex code
    • Promote reusability and modularity
    • Simplify maintenance and debugging
    • Support real-time performance with modern C++ features

    Top 25 OOPs Interview Questions for Embedded Software Engineers

    1. What is Object-Oriented Programming (OOP)?

    Object-Oriented Programming is a programming paradigm based on the concept of objects. Each object is an instance of a class, which encapsulates data and functions. OOP promotes reusability, modularity, and encapsulation — all essential for embedded systems where code efficiency and scalability matter.

    2. What are the main principles of OOP?

    There are four major principles:

    • Encapsulation: Hides internal details, exposes functionality
    • Abstraction: Shows only essential features
    • Inheritance: Reuses code across similar classes
    • Polymorphism: Allows function overloading and overriding

    3. How is OOP different in embedded systems compared to desktop systems?

    Embedded systems have limited memory and processing power, so OOP features must be used judiciously. For example, virtual functions and dynamic memory allocation can impact performance and are often avoided or replaced with static polymorphism (CRTP).

    4. What is a class and object?

    • Class: A blueprint defining data members and member functions
    • Object: A runtime instance of a class
    class LED {
      int pin;
    public:
      LED(int p): pin(p) {}
      void on() { digitalWrite(pin, HIGH); }
    };
    LED led1(13);
    

    5. What is encapsulation? How is it useful in embedded?

    Encapsulation hides implementation details, making code safer and modular. In embedded systems, it helps to limit direct hardware access and prevent bugs.

    6. Explain access specifiers: public, private, protected

    • public: Accessible from anywhere
    • private: Accessible only within the class
    • protected: Accessible in class and its derived classes

    7. What is constructor and destructor in C++?

    • Constructor: Automatically invoked when an object is created
    • Destructor: Automatically called when object goes out of scope
      Used in embedded for initializing hardware and releasing resources.

    8. What is constructor overloading?

    You can define multiple constructors with different parameters:

    class Timer {
    public:
      Timer() {}
      Timer(int delay) { /* Init with delay */ }
    };
    

    9. What is a copy constructor?

    It creates a copy of an object. Useful in embedded when passing objects by value.

    10. What is inheritance and how is it used?

    Inheritance allows creating new classes from existing ones, improving code reuse.

    class Sensor { /* Base */ };
    class TempSensor: public Sensor { /* Derived */ };
    

    11. What is function overloading vs overriding?

    • Overloading: Same function name, different parameters
    • Overriding: Redefining a base class method in a derived class using virtual

    12. What are virtual functions?

    Used for runtime polymorphism. In embedded systems, they should be used cautiously due to the added vtable overhead.

    13. What is pure virtual function and abstract class?

    A pure virtual function makes a class abstract. It’s used to enforce interfaces.

    class Interface {
    public:
      virtual void init() = 0;
    };
    

    14. What is static polymorphism?

    Also known as compile-time polymorphism, achieved using templates or function overloading. Preferred in embedded to avoid runtime overhead.

    15. What are friend functions and classes?

    They bypass encapsulation. Use only when needed in embedded code to access private data (e.g., during low-level hardware debugging).

    16. What is the ‘this’ pointer?

    Points to the current object. Used for object chaining or distinguishing between member and local variables.

    17. What are static data members and static functions?

    • Shared across all objects
    • Useful in embedded for tracking hardware state or shared resources

    18. What is the difference between composition and inheritance?

    • Inheritance: “is-a” relationship
    • Composition: “has-a” relationship

    Prefer composition in embedded to keep class hierarchy shallow and manageable.

    19. What is multiple inheritance and why is it risky?

    A class inherits from more than one base class. Risky in embedded due to ambiguity and complexity. Use interfaces or composition instead.

    20. What is object slicing?

    Occurs when an object of a derived class is assigned to a base class object, losing the derived part. Avoid this in embedded systems by using pointers or references.

    21. What is the role of constructors in embedded hardware abstraction?

    Constructors are used to initialize hardware resources, such as pins, registers, or peripherals, when objects are created.

    22. How do you implement state machines using OOPs in embedded systems?

    Using inheritance and polymorphism, each state can be a class, and transitions can be managed via function calls — clean and scalable.

    23. What is CRTP (Curiously Recurring Template Pattern)?

    Used in embedded systems for static polymorphism without runtime cost.

    template<typename Derived>
    class Base {
      void doSomething() {
        static_cast<Derived*>(this)->impl();
      }
    };
    

    24. How does OOP help in hardware abstraction?

    You can abstract hardware modules (UART, SPI, ADC) as classes with clean interfaces. This decouples application logic from hardware-specific code.

    25. What OOP features should be avoided or used carefully in embedded C++?

    Avoid:

    • Heap allocation (new, delete)
    • Virtual functions in performance-critical paths
    • RTTI and exceptions (not always supported in embedded toolchains)

    Final Thoughts

    Understanding OOPs concepts in C++ for embedded systems is vital to writing clean, maintainable, and scalable code. While embedded software places some constraints on typical OOP usage, modern C++ (especially C++17 and C++20) enables powerful yet efficient patterns suitable for real-time applications.

    If you are preparing for an embedded systems interview, these 25 OOPs interview questions will strengthen your understanding and help you ace your technical rounds.

    Master 25 OOPs Interview Questions for Embedded Software Engineers
    Master 25 OOPs Interview Questions for Embedded Software Engineers (2025)