Theory
The program that outgrew itself
In BCA104 you built the marks program in C: a handful of functions, a few global variables, done.
Now imagine the college canteen asks you for till software: menu items, prices, member discounts, daily totals. You write it C-style: one global total, global arrays, 14 functions all touching them.
Then one function updates total at the wrong moment. Every bill after 3 pm is wrong, and you cannot tell which of the 14 functions did it.
Theory
Open kitchen vs stations
A procedural program is an open kitchen: every cook can reach every shelf, so one careless hand ruins the dal for everyone.
An OOP program runs like stations with counters: the tea station owns its kettle, the billing station owns the cash. You do not grab their things, you place a request at the counter. Each station protects its own ingredients.
Theory
The two styles, formally
Procedural programming structures a program as a sequence of procedures (functions) that operate on data, and the data is typically shared or global. C works this way.
Object-Oriented Programming (OOP) structures a program as a collection of objects: units that bundle data (member variables) together with the functions allowed to touch that data (member functions). C++ works this way.
The deep difference: procedural thinking asks "what steps happen?", OOP thinking asks "what things exist, and what can each do?"
At a glance
Procedural vs OOP, the exam table
| Aspect | Procedural (C) | OOP (C++) |
|---|---|---|
| Focus | Functions (the steps) | Objects (data + behaviour) |
| Data | Shared or global, open to all | Bundled in objects, hidden |
| Design | Top-down | Bottom-up |
| Reuse | Call functions again | Inheritance extends classes |
| Safety | Any function can corrupt data | Access control guards data |
| Examples | C, Pascal | C++, Java, Python |
Quiz
In the C-style canteen till, `total` is a global variable. A wrong amount appears in it. What makes this bug hard to find?
- Every one of the 14 functions could have written to total, so all are suspects
- Global variables cannot store decimal values
- C programs cannot be debugged
- The bug must be in main(), globals are only changed there
Show the answer
Every one of the 14 functions could have written to total, so all are suspects
Global data has no owner: any function can modify it, so the search space is the whole program. That is exactly the pain OOP removes by giving data to an object and allowing changes only through its member functions. The other options are false beliefs: globals hold any type, C is debuggable, and any function (not just main) can write a global.
Theory
The four pillars you are about to study
This whole subject unpacks four OOP ideas:
- Encapsulation: data + functions sealed in one unit (the station).
- Abstraction: show the counter, hide the kitchen.
- Inheritance: build a new class from an existing one (Student card from Person card).
- Polymorphism: one call, many behaviours (one
bill()that discounts differently for students and staff).
Every later topic is one of these pillars in detail.
Think first
Classify it
A program has functions addItem(), printBill(), applyDiscount(), and all three read and write one global array menu[50]. Before tapping: is this procedural or object-oriented, and what single word tells you?
Show the answer
Procedural. The giveaway word is global: the data lives outside any object and every function can reach it directly. Having functions is not the test (OOP has member functions too). The test is who owns the data. In OOP, menu would live inside a class and only its member functions could touch it.
Watch out
The trap: ".cpp" does not mean OOP
Writing your BCA104-style code in a file ending in .cpp does not make it object-oriented. C++ allows both styles, and a main() full of global data is still procedural.
OOP is a design choice, not a file extension. Exams love the question "Is C++ purely object-oriented?" The safe answer: no, C++ is partially OOP because it supports procedural code too (and main() itself is a free function).
Theory
Why this matters beyond marks
Every serious system you will meet (Android apps in Java/Kotlin, Django in Python, game engines in C++) is object-oriented, because teams of 50 cannot share one open kitchen. When an interviewer asks "why OOP?", the winning answer is about maintainability at scale: bugs stay inside one class instead of leaking across the program.
Summary
Key takeaways
- Procedural programming = functions acting on shared or global data, top-down design (C).
- OOP = objects that bundle data with the member functions allowed to touch it, bottom-up design (C++).
- Global data has no owner, so any function is a suspect when it corrupts; OOP gives data an owner.
- Four pillars ahead: encapsulation, abstraction, inheritance, polymorphism.
- C++ is not purely OOP: it happily runs procedural code too, OOP is a design choice.
- Memory hook: open kitchen vs stations with counters.