CPP Tutorials

OOPS Concepts in C++: An Easy Guide.

Welcome, future coders! Today, we embark on a journey into the world of Object-Oriented Programming (OOPS) in C++. Just like building a Lego castle with different types of blocks, OOPS enables us to create different objects, each with its own unique properties and functions. These objects work together like Lego blocks, helping us construct complex programs more efficiently. In this article, we’ll explore why we need OOPS, what it is, and how we can use it to build powerful and organized software. So, let’s unleash our creativity and dive into the exciting realm of OOPS in C++!


Object-Oriented Programming (OOPS) in C++ is like organizing our code into reusable building blocks. It helps us break complex problems into smaller, manageable pieces, making our code more organized and easier to understand. With OOPS, we can create objects that represent real-world entities and define their behaviors, just like playing with Lego blocks.

This approach makes it easier to maintain and modify our code, saving us time and effort. OOPS is a powerful tool that enables us to build more efficient and flexible software, making our programming journey smoother and more enjoyable.

What Is OOPS in C++?

Object-oriented programming (OOP) is like building with virtual blocks. Just as you can make things from blocks, in programming, we use objects to make things happen. Each object has its own data (like attributes of a car) and actions (like driving). OOP is about keeping these things together so they work smoothly. Imagine a toy car – you can’t change its speed by poking its wheels, right? You use the buttons made for it. Similarly, OOP keeps things organized and safe by only allowing the right “buttons” (methods) to interact with the data, making coding easier and less messy.

There are some basic concepts that act as the building blocks of OOPs i.e.

  1. Class
  2. Objects
  3. Encapsulation
  4. Abstraction
  5. Polymorphism
  6. Inheritance
  7. Dynamic Binding
  8. Message Passing
OOPS Concepts

Characteristics of an Object-Oriented Programming Language


In C++, a Class serves as the foundation for Object-Oriented programming. It’s a custom-made data type that contains its own characteristics (data members) and actions (member functions). To utilize a class, you create an example of it. Think of a class as a template for creating objects. For example, think about the concept of Cars. Although there are many cars with different names and brands, they all share common features like having 4 wheels, speed limits, and mileage. In this scenario, the Car acts as the class, while the shared attributes such as wheels, speed limits, and mileage are its properties.

A Class is a custom-defined data type that contains both data members (variables) and member functions (functions). Data members are used to store specific information, while member functions work with this information to perform various operations. Together, these data members and member functions establish the characteristics and actions of objects belonging to the Class.

For example, in the context of a “Car” Class, data members might contain attributes like speed limit and mileage, while the associated member functions could involve actions such as applying brakes and increasing speed. Essentially, a Class serves as a template guiding the creation of objects that share common attributes and behaviors. Objects, in turn, are instances of a Class and adhere to the guidelines laid out by that Class.


In C++, an object is like a blueprint that defines a specific type of data structure, along with the actions or functions that can be performed on that data. It’s a way to create your own custom data type.

Think of an object as a template for creating something. For example, if you want to represent cars in a computer program, you can create an object called “Car.” This object would have attributes like color, model, and year, and it could have functions like “startEngine()” and “accelerate().”

When you create an object based on this template, you’re making an instance of that object. It’s like building a real car from the blueprint. Each instance of an object can have its own specific values for its attributes, and you can use the functions defined in the object to perform actions on it.


ClassName objectName;

Code Example:

#include <iostream>
#include <string>
using namespace std;

class Car {
    string color;
    string model;
    int year;
    bool engineStarted;

    Car(string col, string mdl, int yr) : color(col), model(mdl), year(yr), engineStarted(false) {}

    void startEngine() {
        engineStarted = true;
        cout << "Engine started." << endl;

    void accelerate() {
        if (engineStarted) {
            cout << "Car is accelerating." << endl;
        } else {
            cout << "Please start the engine first." << endl;

    void displayInfo() {
        cout << "Color: " << color << endl;
        cout << "Model: " << model << endl;
        cout << "Year: " << year << endl;

int main() {
    Car myCar("Red", "Sedan", 2023);


    return 0;


Color: Red
Model: Sedan
Year: 2023
Engine started.
Car is accelerating.


  • The Car class defines a car object with attributes: color, model, year, and engine status.
  • Member functions:
    • startEngine(): Starts the car’s engine and updates engine status.
    • accelerate(): Accelerates the car if the engine is started, else prompts to start it.
    • displayInfo(): Displays the car’s color, model, and year.
  • The main() function:
    • Creates a car object with attributes “Red”, “Sedan”, and 2023.
    • Displays car information using displayInfo().
    • Starts the engine using startEngine() and confirms.
    • Accelerates the car using accelerate() if the engine is started.


Encapsulation in C++ is a concept that involves bundling data (attributes) and the methods (functions) that operate on that data into a single unit known as a class. This helps in keeping the data safe from direct access and manipulation from outside the class. In other words, encapsulation ensures that the internal implementation details of a class are hidden, and only specific methods can interact with the data. It provides a way to control and restrict access to the data, promoting data integrity and security.

Think of encapsulation as putting your data and functions related to that data inside a protective container. You can only interact with the data through the methods provided by the class. This way, the class can ensure that the data is used in a controlled and consistent manner, reducing the chances of errors or unintended modifications.

For example, if you have a class representing a bank account, encapsulation would allow you to hide the account balance from being directly changed outside of the class. Instead, you would provide methods like “deposit” and “withdraw” to interact with the balance, ensuring that the balance is always updated correctly and securely.


Data abstraction is a fundamental concept in C++ programming that’s essential for object-oriented programming. Abstraction means showing only the necessary information while hiding the intricate details. In C++, data abstraction involves sharing only the crucial data details with the outside world and keeping the inner workings hidden. To understand this, think of a person driving a car. The driver knows that pressing the gas pedal increases speed and using brakes stops the car, but they don’t need to know the complex mechanisms inside the car.

Using Classes for Abstraction: We achieve abstraction in C++ through classes. A class lets us group data variables and functions using various access settings. With a class, we can control which data is visible externally and which remains hidden.

Abstraction with Header Files: Another way to practice abstraction in C++ is through header files. For instance, think of the ‘pow()’ function in the ‘math.h’ header file. Whenever we want to calculate a number’s power, we can simply call the pow() function from the math.h header without needing to understand the detailed calculations happening behind the scenes.


Polymorphism means something having many forms. In simpler terms, it’s like a message being shown in multiple ways. Think of a person who can act differently in various roles: a father, a husband, an employee – all at the same time. This is what polymorphism is about. It’s when a single operation can behave differently based on the situation or data it’s dealing with.

For example, in C++, you can make an operator do different things depending on the context – that’s called operator overloading. Similarly, you can have a single function name, but it can perform different tasks based on the input – this is function overloading. Polymorphism is used a lot when working with inheritance, a key concept in programming.

Code Example:

#include <iostream>
using namespace std;

class Shape {
    virtual void draw() {
        cout << "Drawing a shape." << endl;

class Circle : public Shape {
    void draw() override {
        cout << "Drawing a circle." << endl;

class Square : public Shape {
    void draw() override {
        cout << "Drawing a square." << endl;

int main() {
    Shape* shapePtr;
    Circle circle;
    Square square;

    shapePtr = &circle;

    shapePtr = □

    return 0;


Drawing a circle.
Drawing a square.


  • The example involves a base class named “Shape” with a virtual function called “draw()”.
  • Two derived classes are created: “Circle” and “Square”, both overriding the “draw()” function.
  • In the “main()” function, instances of “Circle” and “Square” are created.
  • A pointer of type “Shape*” is used, pointing to different shapes at different times.
  • When the “draw()” function is called using the pointer, the appropriate version is executed based on the object it points to.
  • This illustrates polymorphism, where a single function name behaves differently for various objects.


Certainly! Inheritance is a fundamental concept in Object-Oriented Programming that enables a class to inherit properties and characteristics from another class. Think of it like inheriting traits from your parents.

  • Subclass: This is the class that receives those inherited properties. It’s akin to a child inheriting traits from their parents.
  • Superclass: This is the class that provides the inherited properties. It’s similar to parents passing down their traits.

A significant aspect of inheritance is reusability. Suppose you need to create a new class, and there’s already a class with some of the code you require. Inheritance lets you build your new class based on the existing one, reusing its fields and methods. This approach enhances code efficiency and saves time by utilizing what you already have instead of starting anew.

Dynamic Binding

Dynamic binding in C++ refers to the ability of the program to determine which function to call at runtime, rather than at compile time. It’s a key concept in object-oriented programming and is closely related to polymorphism.

In simple terms, dynamic binding allows you to call a function on an object without knowing the exact type of that object. The decision about which function to call is made when the program is running, based on the actual type of the object.

Code Example:

#include <iostream>
using namespace std;

class Animal {
    virtual void speak() {
        cout << "Animal makes a sound." << endl;

class Dog : public Animal {
    void speak() override {
        cout << "Dog barks." << endl;

class Cat : public Animal {
    void speak() override {
        cout << "Cat meows." << endl;

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

    for (int i = 0; i < 3; i++) {

    for (int i = 0; i < 3; i++) {
        delete animals[i];

    return 0;


Dog barks.
Cat meows.
Animal makes a sound.


  • Base class: ‘Animal‘, with a virtual function speak().
  • Derived classes: ‘Dog‘ and ‘Cat‘, both override the ‘speak()‘ function.
  • In ‘main()‘, an array of pointers to ‘Animal‘ is created.
  • Objects of ‘Dog‘, ‘Cat‘, and ‘Animal‘ are assigned to these pointers.
  • A loop calls the ‘speak()‘ function through the pointers.
  • Demonstrates dynamic binding, calling the appropriate function based on the object type.

Message Passing

Objects in programming can talk to each other by sending messages. Think of a message as a request that an object makes to another object to do something. When an object gets a message, it knows what function to perform, and it carries out that function to achieve a specific result. To send a message, we just need to know which object we’re talking to, what action or function we want it to perform, and any details or information it might need. This is how different objects work together and get things done by sharing messages.

A Problem to Solve

Problem Statement: Library Management System

Imagine you are tasked with designing a basic library management system. Use the Object-Oriented Programming System (OOPS) concepts in C++ to design the following:

  • Classes and Objects:
    • Book: Represents a book in the library.
    • Member: Represents a library member.
    • Library: Manages the books and members.
  • Attributes and Methods: Book:
    • Attributes: Title, Author, ISBN number, Status (available or borrowed).
    • Methods: Borrow(), Return(). Member:
    • Attributes: Name, MemberID, List of borrowed books.
    • Methods: BorrowBook(Book book), ReturnBook(Book book). Library:
    • Attributes: List of Books, List of Members.
    • Methods: AddBook(Book book), RemoveBook(Book book), RegisterMember(Member member), DeregisterMember(Member member).
  • Inheritance:
    • Create a derived class from Book named “DigitalBook”.
    • DigitalBook has additional attributes: FileSize, Format (PDF, EPUB, etc.)
  • Encapsulation:
    • Ensure that the internal representation of the Book, Member, and Library are hidden from the outside world.
    • Provide public methods to interact with and manipulate these objects.
  • Polymorphism:
    • Override the Borrow() and Return() methods in the DigitalBook class to include additional functionalities, such as updating the download count.
  • Abstraction:
    • Provide an interface to interact with the Library system. The user should be able to add or remove books, register or deregister members, and borrow or return books without knowing the internal workings of the system.


  • Define the classes, attributes, and methods.
  • Implement the inheritance, encapsulation, polymorphism, and abstraction concepts.
  • Create a test scenario where:
    • A library is initialized.
    • Books and digital books are added.
    • Members register.
    • Members borrow and return books.

Expected Output:

The program should display the various interactions between members and the library, such as borrowing books, returning books, and the current status of the books (whether they’re available or borrowed).

Examples of Using OOPS Concepts in C++

Let’s look at some examples to see how OOPS concepts can be used in C++. We’ll provide the code, the expected output, and a step-by-step explanation of how OOPS is used.

Example 1

using namespace std;

class Car {
    string brand;
    string model;
    int year;

int main() {
    Car carObj1;
    carObj1.brand = "Toyota";
    carObj1.model = "Corolla";
    carObj1.year = 2020;

    cout << carObj1.brand << " " << carObj1.model << " " << carObj1.year << endl;
    return 0;


Toyota Corolla 2020


  • The Car class is defined with three public member variables: brand, model, and year. These variables store information about the brand, model, and manufacturing year of a car.
  • In the main() function:
    • An instance of the Car class named carObj1 is created.
    • The member variables brand, model, and year of carObj1 are assigned specific values using the dot operator (.) and the assignment operator (=).
    • The brand, model, and year of carObj1 are printed to the console using cout and the stream insertion operator (<<).

Example 2

using namespace std;

class Student {
    string name;
    int age;
    float grade;

int main() {
    Student studentObj;
    studentObj.name = "Coder";
    studentObj.age = 20;
    studentObj.grade = 9.5;

    cout << studentObj.name << " " << studentObj.age << " " << studentObj.grade;
    return 0;


Coder 20 9.5


  • The Student class is defined with three public member variables: name, age, and grade. These variables store information about the name, age, and grade of a student.
  • In the main() function:
    • An instance of the Student class named studentObj is created.
    • The member variables name, age, and grade of studentObj are assigned specific values using the dot operator (.) and the assignment operator (=).
    • The name, age, and grade of studentObj are printed to the console using cout and the stream insertion operator (<<).

The Pros and Cons of Using OOPS

Pros of OOPSCons of OOPS
Modularity: Code is divided into classes and objects, making it easier to manage and understand.Complexity: Implementing OOPS concepts can be more complex, especially for beginners.
Reusability: Code can be reused in different parts of the program, reducing redundancy.Overhead: OOPS can add overhead in terms of memory and performance.
Encapsulation: Data and methods are encapsulated within classes, providing data security.Learning Curve: Learning OOPS concepts may take some time and effort.
Polymorphism: Ability to use the same interface for different data types, increasing flexibility.Overdesign: Overusing OOPS can lead to unnecessary complexity in small projects.
Inheritance: Classes can inherit properties and behaviors from other classes, promoting code reuse.Abstraction: Understanding complex OOPS designs may require a deeper level of abstraction.
The pros and cons of using Object-Oriented Programming (OOPS) in C++

Key Takeaways

  • OOPS in C++ allows us to create objects with their own properties and methods.
  • It helps in organizing and structuring code by using classes and objects.
  • Objects can be easily reused in different parts of the program, reducing redundancy.
  • Data and methods are encapsulated within classes, providing data security.
  • Polymorphism allows using the same interface for different data types, increasing flexibility.
  • Inheritance enables classes to inherit properties and behaviors from other classes, promoting code reuse.
  • Understanding OOPS concepts can lead to more structured and intuitive programs.


In conclusion, Object-Oriented Programming (OOPS) is a powerful concept in C++. It allows us to create objects with their own unique properties and methods, making our code more organized and intuitive. By mastering OOPS, you can write better, more efficient programs. So keep learning and practicing, and soon you’ll become skilled at using OOPS to build amazing software solutions. Embrace the world of OOPS in C++, and let it unleash your creativity as you design and develop innovative applications. Happy coding, future programmers!


  • What is OOPS in C++?
    OOPS in C++ is a programming paradigm that allows us to create objects with their own properties and methods.
  • Why do we use OOPS in C++?
    We use OOPS in C++ to make our programs more structured and intuitive. It allows us to create objects with their own properties and methods.
  • How do we use OOPS in C++?
    We use OOPS in C++ by creating classes and objects. A class is like a blueprint for creating objects.
  • Can using OOPS make code more confusing?
    Yes, if you use OOPS incorrectly, it can lead to problems like increased complexity and decreased performance. It’s important to understand how OOPS works and when to use it.
  • What are some examples of using OOPS in C++?
    Some examples include creating a ‘Car’ class and creating objects of the ‘Car’ class, and creating a ‘Student’ class and creating objects of the ‘Student’ class.

Related Articles

Leave a Reply

Your email address will not be published. Required fields are marked *

Back to top button
Becoming a Full Stack Developer in 2023 How to Become a Software Engineer in 2023

Adblock Detected

Please consider supporting us by disabling your ad blocker!