C++ Interview Questions - Object-Oriented Programming (OOP)

Welcome to this comprehensive guide on C++ Interview Questions focused on Object-Oriented Programming (OOP). We'll dive deep into essential OOP concepts, practical examples, and quizzes to help you master this key programming paradigm. Let's get started!

Introduction 🎯

In this lesson, we'll explore various Object-Oriented Programming (OOP) concepts in C++. OOP is a programming paradigm that aims to design programs based on real-world objects and their interactions. Let's set the stage with a brief overview of the key OOP principles:

Encapsulation: Hiding the implementation details and only exposing what is necessary to the outside world.
Inheritance: A mechanism where a new class inherits properties and methods from an existing class.
Polymorphism: The ability of an object to take on many forms, especially in the context of method overriding and function overloading.
Abstraction: Focusing on the essential features and hiding complex details.

Encapsulation 📝

Encapsulation in C++ is achieved through classes and objects. A class defines a blueprint for creating objects, and it hides the implementation details from the outside world.

cpp

#include <iostream>

class MyClass {
private:
    int myPrivateVariable;
public:
    void setPrivateVariable(int value) {
        myPrivateVariable = value;
    }
    int getPrivateVariable() {
        return myPrivateVariable;
    }
};

int main() {
    MyClass myObject;
    myObject.setPrivateVariable(10);
    std::cout << "Private variable value: " << myObject.getPrivateVariable() << std::endl;
    return 0;
}

💡 Pro Tip: Always use the private keyword to hide the implementation details and the public keyword to expose methods and variables to the outside world.

Inheritance 📝

Inheritance allows a new class to inherit properties and methods from an existing class, called the base class or superclass. The new class, called the derived class or subclass, can then extend or modify the behavior of the base class.

cpp

#include <iostream>

class BaseClass {
public:
    void printBase() {
        std::cout << "Base class\n";
    }
};

class DerivedClass : public BaseClass {
public:
    void printDerived() {
        std::cout << "Derived class\n";
    }
};

int main() {
    DerivedClass derivedObj;
    derivedObj.printBase();
    derivedObj.printDerived();
    return 0;
}

💡 Pro Tip: Use : public BaseClass to inherit from a base class, and virtual keyword for polymorphism (which we'll cover next).

Polymorphism 📝

Polymorphism allows objects of different classes to be treated as objects of a common base class. This is achieved through method overriding and function overloading.

cpp

#include <iostream>

class Animal {
public:
    virtual void makeSound() {
        std::cout << "Animal makes a sound.\n";
    }
};

class Dog : public Animal {
public:
    void makeSound() {
        std::cout << "Dog barks.\n";
    }
};

class Cat : public Animal {
public:
    void makeSound() {
        std::cout << "Cat meows.\n";
    }
};

int main() {
    Animal *animals[2];
    animals[0] = new Dog;
    animals[1] = new Cat;

    for (int i = 0; i < 2; i++) {
        animals[i]->makeSound();
    }

    return 0;
}

💡 Pro Tip: Use the virtual keyword to enable polymorphism, and remember that the most derived class (in this case, Dog and Cat) will override the method of the base class (Animal).

Quiz 🎯

Abstraction 📝

Abstraction in C++ is achieved through pure virtual functions and abstract classes. An abstract class is a class that cannot be instantiated but can be inherited.

cpp

#include <iostream>

abstract class Shape {
public:
    virtual void draw() = 0;
};

class Circle : public Shape {
public:
    void draw() {
        std::cout << "Drawing a circle.\n";
    }
};

class Rectangle : public Shape {
public:
    void draw() {
        std::cout << "Drawing a rectangle.\n";
    }
};

int main() {
    Shape *shapes[2];
    shapes[0] = new Circle;
    shapes[1] = new Rectangle;

    for (int i = 0; i < 2; i++) {
        shapes[i]->draw();
    }

    return 0;
}

💡 Pro Tip: Use pure virtual functions and abstract classes to achieve abstraction in C++.

That's it for our deep dive into C++ Object-Oriented Programming (OOP) concepts! Practice makes perfect, so try implementing these concepts in your own projects and stay tuned for more comprehensive lessons on C++ programming at CodeYourCraft. Happy coding! 💪

This content was generated using the provided guidelines. If you found it helpful, please consider sharing it with your friends and colleagues.