Difference between POP and OOP in C++

Object-Oriented Programming (OOP)

“Object-oriented programming in C++ is basically about classes and objects, then the various concepts like polymorphism, encapsulation, abstraction, and inheritance.”

The programming concept of Object-Oriented Programming (OOP) utilizes classes, objects, inheritance, and polymorphism. OOP arranges code into attributes (data members) and methods (functions) classes. You can create objects from these classes to represent real-life entities with unique characteristics and behaviors.

Example program on OOP:

#include <iostream>

#include <string>

class Person {

private:

    std::string name;

    std::string dob;

public:

    // Constructor

    Person(const std::string& n, const std::string& d) : name(n), dob(d) {}

    // Method to display name and date of birth

    void displayInfo() {

        std::cout << "Name: " << name << std::endl;

        std::cout << "Date of Birth: " << dob << std::endl;

    }

};

int main() {

    std::string name, dob;

    // Get input from the user

    std::cout << "Enter name: ";

    getline(std::cin, name);

    std::cout << "Enter date of birth: ";

    getline(std::cin, dob);

    // Create a Person object with the provided data

    Person person(name, dob);

    // Display the person's information

    std::cout << "\nPerson's Information:\n";

    person.displayInfo();

    return 0;

}

Output:

Explanation:

In this code, the idea of keeping data (such as a person's name and date of birth) within a class (called "Person") and using methods (like "displayInfo()") to work with that data is shown it is called as encapsulation. Encapsulation is a vital concept in Object-Oriented Programming, where data and the functions taken on that data are grouped into classes to make the code organized and easy to maintain.

Characteristics of OOPS

1. Classes and objects

Classes and objects revolve around OOP. A class is a blueprint for objects that determines their structure and behavior. An object is a class instance that represents a specific entity or concept.

2. Abstraction

Abstraction involves hiding unnecessary details.

3. Encapsulation

Encapsulation is the process of combining data and the methods that operate on that data into one unit.

4. Inheritance

A class (subclass or derived class) can inherit properties and behaviors from another class (superclass or base class).

5. Polymorphism

Polymorphism allows objects of various classes to be viewed as belonging to the same superclass.

6. Message Passing

Objects communicate in OOP by sending messages to one another.

7. Modularity and reusability

Using classes and objects, OOP facilitates the creation of modular and reusable programming.

8. Data hiding

OOP provides techniques for controlling an object's visibility and accessibility.

Procedural Programming (POP)

“Procedural Oriented Programming (POP) is a programming methodology emphasizing the importance of functions or procedures needed for computation rather than the data.” POP entails breaking down the program into functions using a sequence of instructions, with each task completed in a specific order. These functions share global data or variables and exchange data between them. Essentially, POP follows a step-by-step approach.

In procedural programming, modularity is a key principle. Programs are divided into smaller, modular functions that have specific tasks. Modular functions help in better understanding, testing, and maintaining the code. This approach makes it easier to make changes without impacting the entire program.

Example program to showcase POP.

#include <iostream>

//function to calculate the factorial of a number

int factorial(int n) {

    int res = 1;

    for (int i = 1; i <= n; ++i) {

        res *= i;

    }

    return res;

}

int main() {

    int number;

    // Input

    std::cout << "Enter a number: ";

    std::cin >> number;

    // Calculate factorial

    int fact = factorial(number);

    // Output

    std::cout << "Factorial of " << number << " is: " << fact << std::endl;

    return 0;

}

Output:

Explanation:

The above program is an example of procedural programming, which involves breaking down a problem into smaller, modular functions (input, calculation, output) and following a linear flow of execution. This program uses a loop to calculate the factorial of a given number using the factorial function. The main function prompts the user for input, calculates the factorial using the factorial function, and displays the result.

Characteristics of POP

• POP is based on breaking down a program into smaller procedures or functions that execute specific tasks.
• POP does well at algorithmic or mathematical activities.
• POP executes the code sequentially, one after the other procedure.
• POP executes the code sequentially, running each procedure one after the other.
• As programs grow larger, it becomes challenging to maintain and modify.
• POP is frequently used for basic programs or projects involving simple procedures and calculations.

Procedural-Oriented Programming vs Object Oriented Programming

Conclusion:

The choice between POP and OOP is determined by the nature of the problem and the goals of your programming project. Because it provides a more structured and organized approach to describing and interacting with data and behaviour, OOP is generally preferred for larger projects or projects that involve modeling complicated real-world relationships. However, both approaches have advantages and disadvantages and might be effective in different situations. Modern programming languages frequently allow you to mix and match different paradigms to meet your individual requirements.