OOP principles overview in C++ - Mini Project: Build & Apply

OOP Principles Overview in C++

📖 Scenario: You are creating a simple program to understand the basic principles of Object-Oriented Programming (OOP) in C++. This program will help you see how classes and objects work, and how encapsulation, inheritance, and polymorphism are used in real life.

🎯 Goal: Build a C++ program that demonstrates the four main OOP principles: encapsulation, inheritance, polymorphism, and abstraction using simple classes and methods.

📋 What You'll Learn

Create a class with private data members to show encapsulation

Add a public method to access private data

Create a derived class to demonstrate inheritance

Use a virtual function to show polymorphism

Print outputs to show how each principle works

💡 Why This Matters

🌍 Real World

OOP is used to model real-world things like animals, vehicles, or users in software, making programs easier to understand and maintain.

💼 Career

Understanding OOP is essential for software development jobs, as it is the foundation of many programming languages and frameworks.

1

Create a class with private data members

Create a class called Animal with a private string variable name. Add a public constructor that takes a string parameter to set name. Add a public method getName() that returns the name.

C++

class Animal {
private:
    std::string name;
public:
    // Your code here
};

Need a hint?

Remember to keep name private and provide a public constructor and getter method.

2

Add a derived class to demonstrate inheritance

Create a class called Dog that inherits from Animal. Add a public constructor to Dog that takes a string parameter and passes it to the Animal constructor.

C++

#include 
#include 

class Animal {
private:
    std::string name;
public:
    Animal(std::string n) {
        name = n;
    }
    std::string getName() {
        return name;
    }
};

// Your code here

Need a hint?

Use class Dog : public Animal and call the base constructor in the initializer list.

3

Add a virtual function to demonstrate polymorphism

In the Animal class, add a public virtual method makeSound() that returns a string "Some sound". Override this method in the Dog class to return "Bark".

C++

#include 
#include 

class Animal {
private:
    std::string name;
public:
    Animal(std::string n) {
        name = n;
    }
    std::string getName() {
        return name;
    }
    // Your code here
};

class Dog : public Animal {
public:
    Dog(std::string n) : Animal(n) {
    }
    // Your code here
};

Need a hint?

Use virtual keyword in base class and override in derived class.

4

Create objects and print outputs to show OOP principles

Create an Animal object called animal with name "Generic" and a Dog object called dog with name "Buddy". Use pointers of type Animal* to point to both objects. Print the name and sound of both objects using getName() and makeSound().

C++

#include 
#include 

class Animal {
private:
    std::string name;
public:
    Animal(std::string n) {
        name = n;
    }
    std::string getName() {
        return name;
    }
    virtual std::string makeSound() {
        return "Some sound";
    }
};

class Dog : public Animal {
public:
    Dog(std::string n) : Animal(n) {
    }
    std::string makeSound() override {
        return "Bark";
    }
};

int main() {
    // Your code here
    return 0;
}

Need a hint?

Use pointers of type Animal* to point to both objects and call methods.