Procedural vs OOP approach in C++ - Hands-On Comparison

Procedural vs OOP approach

📖 Scenario: You are building a simple program to manage information about books in a library. First, you will create the program using a procedural style, then you will rewrite it using object-oriented programming (OOP) style.

🎯 Goal: Learn how to organize code in two ways: procedural and object-oriented. You will create a simple program that stores book details and prints them.

📋 What You'll Learn

Create a procedural version using variables and functions

Create an OOP version using a class

Use clear and simple code for both versions

Print book details in both versions

💡 Why This Matters

🌍 Real World

Managing collections of related data like books, students, or products is common in software. Procedural code works for simple tasks, but OOP helps organize bigger programs.

💼 Career

Understanding procedural and OOP approaches is essential for software development jobs. Many projects use classes and objects to keep code clean and reusable.

1

Create procedural data variables

Create three variables: title as a std::string with value "The Great Gatsby", author as a std::string with value "F. Scott Fitzgerald", and year as an int with value 1925.

C++

#include 
#include 

int main() {

    // Create variables title, author, and year with given values
    // Your code here

    return 0;
}

Hint

Use std::string for text and int for numbers.

2

Create a function to print book details

Create a function called printBook that takes three parameters: std::string title, std::string author, and int year. Inside the function, print the book details in the format: Title: [title], Author: [author], Year: [year]. Then call printBook inside main with the variables title, author, and year.

C++

#include 
#include 

// Create function printBook with parameters title, author, year
// Your code here

int main() {
    std::string title = "The Great Gatsby";
    std::string author = "F. Scott Fitzgerald";
    int year = 1925;

    // Call printBook with title, author, year
    // Your code here

    return 0;
}

Hint

Define the function before main. Use std::cout to print.

3

Create a Book class with members

Create a class called Book with three public members: title and author as std::string, and year as int. Inside main, create an object book of type Book and set its title to "The Great Gatsby", author to "F. Scott Fitzgerald", and year to 1925.

C++

#include 
#include 

void printBook(std::string title, std::string author, int year) {
    std::cout << "Title: " << title << ", Author: " << author << ", Year: " << year << std::endl;
}

// Create class Book with public members title, author, year
// Your code here

int main() {
    std::string title = "The Great Gatsby";
    std::string author = "F. Scott Fitzgerald";
    int year = 1925;

    printBook(title, author, year);

    // Create Book object book and set its members
    // Your code here

    return 0;
}

Hint

Define the class before main. Use dot . to set object members.

4

Print book details using the Book object

Add a function called printBookObject that takes a Book object as a parameter and prints its details in the format: Title: [title], Author: [author], Year: [year]. Then call printBookObject inside main with the book object.

C++

#include 
#include 

void printBook(std::string title, std::string author, int year) {
    std::cout << "Title: " << title << ", Author: " << author << ", Year: " << year << std::endl;
}

class Book {
public:
    std::string title;
    std::string author;
    int year;
};

// Create function printBookObject that takes a Book object and prints its details
// Your code here

int main() {
    std::string title = "The Great Gatsby";
    std::string author = "F. Scott Fitzgerald";
    int year = 1925;

    printBook(title, author, year);

    Book book;
    book.title = "The Great Gatsby";
    book.author = "F. Scott Fitzgerald";
    book.year = 1925;

    // Call printBookObject with book
    // Your code here

    return 0;
}

Hint

Use std::cout inside printBookObject to print the object's members.

Practice

1.

Which of the following best describes procedural programming?

Procedural programming:

easy

A. Uses functions and step-by-step instructions to solve problems.

B. Groups data and functions inside classes called objects.

C. Focuses on creating reusable components with inheritance.

D. Uses event-driven programming with callbacks.

Solution

1. Step 1: Understand procedural programming basics

   Procedural programming organizes code as a sequence of instructions and functions.

2. Step 2: Compare with other programming styles

   OOP groups data and functions in classes, which is different from procedural style.

3. Final Answer:

   Uses functions and step-by-step instructions to solve problems. -> Option A

4. Quick Check:

   Procedural = step-by-step functions [OK]

Hint: Procedural = functions + steps, OOP = classes + objects [OK]

Common Mistakes:

• Confusing OOP with procedural programming
• Thinking procedural uses classes
• Mixing event-driven with procedural

2.

Which of the following is the correct way to define a class in C++?

?

easy

A. function MyClass() { }

B. class MyClass { public: void display(); };

C. def MyClass(): pass

D. struct MyClass() { void display(); };

Solution

1. Step 1: Recall C++ class syntax

   In C++, classes are defined using the keyword class followed by the class name and braces.

2. Step 2: Check each option

   class MyClass { public: void display(); }; uses correct C++ syntax. function MyClass() { } is JavaScript style. def MyClass(): pass is Python. struct MyClass() { void display(); }; has incorrect struct syntax.

3. Final Answer:

   class MyClass { public: void display(); }; -> Option B

4. Quick Check:

   C++ classes start with 'class' keyword [OK]

Hint: C++ classes start with 'class' keyword, not function or def [OK]

Common Mistakes:

• Using function or def keywords instead of class
• Confusing struct syntax with class
• Missing semicolon after class definition

3.

What will be the output of the following C++ code?

#include <iostream>
class Counter {
public:
    int count = 0;
    void increment() { count++; }
};

int main() {
    Counter c;
    c.increment();
    c.increment();
    std::cout << c.count << std::endl;
    return 0;
}

medium

A. 0

B. 1

C. 2

D. Compilation error

Solution

1. Step 1: Understand the class and method

   The class Counter has a member variable count initialized to 0 and a method increment() that adds 1 to count.

2. Step 2: Trace the main function calls

   In main, an object c is created. increment() is called twice, so count becomes 2. Then count is printed.

3. Final Answer:

   2 -> Option C

4. Quick Check:

   Two increments increase count to 2 [OK]

Hint: Each increment adds 1, called twice means count = 2 [OK]

Common Mistakes:

• Forgetting to initialize count to 0
• Assuming increment returns a value
• Confusing count with method call

4.

Identify the error in this procedural-style C++ code and fix it:

int total = 0;
void add(int value) {
    total += value;
}

int main() {
    add(5);
    add(10);
    std::cout << total << std::endl;
    return 0;
}

medium

A. Missing #include <iostream> for std::cout.

B. Function add should return int.

C. No error, code works fine.

D. Variable total should be inside main.

Solution

1. Step 1: Check for missing includes

   The code uses std::cout but does not include <iostream>, which is required for output.

2. Step 2: Verify other parts

   Function add correctly modifies global total. Returning int is not required. total can be global for procedural style.

3. Final Answer:

   Missing #include <iostream> for std::cout. -> Option A

4. Quick Check:

   Always include <iostream> for std::cout [OK]

Hint: Missing #include <iostream> causes std::cout errors [OK]

Common Mistakes:

• Thinking add must return a value
• Moving total inside main breaks add function
• Ignoring missing include errors

5.

You want to model a simple bank account in C++. Which approach is better and why?

Options:

• Procedural: Use global variables for balance and functions to deposit/withdraw.
• OOP: Create a BankAccount class with balance as private and methods for deposit/withdraw.

hard

A. Procedural is better because it is simpler and uses fewer lines of code.

B. OOP is worse because it cannot handle simple tasks like bank accounts.

C. Procedural is better because classes are slow and complex.

D. OOP is better because it groups data and functions, protecting balance and making code reusable.

Solution

1. Step 1: Understand the problem domain

   A bank account needs to protect its balance and provide controlled access to deposit and withdraw money.

2. Step 2: Compare procedural and OOP approaches

   Procedural uses global variables which can be changed anywhere, risking errors. OOP encapsulates balance inside a class, controlling access and improving code reuse.

3. Final Answer:

   OOP is better because it groups data and functions, protecting balance and making code reusable. -> Option D

4. Quick Check:

   OOP encapsulates data and behavior safely [OK]

Hint: Use OOP to protect data and group related functions [OK]

Common Mistakes:

• Assuming procedural is always simpler
• Thinking classes slow down simple programs
• Ignoring data protection benefits of OOP