Theory
એ program જે પોતાનાથી મોટો થઈ ગયો
BCA104 માં તમે C માં marks નો program બનાવ્યો હતો: મુઠ્ઠીભર functions, થોડાં global variables, પૂરું.
હવે કલ્પો કે college ની canteen તમારી પાસે બિલિંગનું software માંગે છે: menu ની વસ્તુઓ, ભાવ, સભ્યોનું discount, રોજનું કુલ. તમે એ C ની શૈલીમાં લખો છો: એક global total, global arrays, અને એમને અડતાં 14 functions.
પછી એક function ખોટા સમયે total સુધારે છે. બપોરે 3 પછીનું દરેક બિલ ખોટું છે, અને 14 માંથી કયા function એ કર્યું એ તમે કહી શકતા નથી.
Theory
ખુલ્લું રસોડું સામે stations
Procedural program એ ખુલ્લું રસોડું છે: દરેક રસોઇયો દરેક છાજલી સુધી પહોંચી શકે છે, એટલે એક બેદરકાર હાથ બધા માટે દાળ બગાડે છે.
OOP નો program counter વાળાં stations ની જેમ ચાલે છે: ચાનું station પોતાની કીટલી ધરાવે છે, બિલિંગનું station રોકડ ધરાવે છે. તમે એમની વસ્તુઓ ઝૂંટવતા નથી, તમે counter પર વિનંતી મૂકો છો. દરેક station પોતાની સામગ્રીનું રક્ષણ કરે છે.
Theory
બે શૈલી, ઔપચારિક રીતે
Procedural programming એ program ને data પર કામ કરતી પ્રક્રિયાઓ (functions) ના ક્રમ તરીકે રચે છે, અને data સામાન્ય રીતે વહેંચાયેલો કે global હોય છે. C આ રીતે કામ કરે છે.
Object-Oriented Programming (OOP) એ program ને objects ના સંગ્રહ તરીકે રચે છે: એવા એકમો જે data (member variables) ને એ data ને અડવાની છૂટ ધરાવતાં functions (member functions) સાથે બાંધે છે. C++ આ રીતે કામ કરે છે.
ઊંડો ભેદ: procedural વિચાર પૂછે છે "કયાં પગલાં થાય છે?", OOP નો વિચાર પૂછે છે "કઈ વસ્તુઓ અસ્તિત્વમાં છે, અને દરેક શું કરી શકે છે?"
At a glance
Procedural સામે OOP, પરીક્ષાનું કોષ્ટક
| પાસું | Procedural (C) | OOP (C++) |
|---|---|---|
| ધ્યાન | Functions (પગલાં) | Objects (data વત્તા વર્તન) |
| Data | વહેંચાયેલો કે global, બધા માટે ખુલ્લો | Objects માં બંધાયેલો, છુપાયેલો |
| રચના | ઉપરથી નીચે | નીચેથી ઉપર |
| ફરી વાપરવું | Functions ફરી બોલાવો | Inheritance classes ને લંબાવે છે |
| સલામતી | કોઈ પણ function data બગાડી શકે | Access control data નું રક્ષણ કરે છે |
| ઉદાહરણ | C, Pascal | C++, Java, Python |
Quiz
C શૈલીના canteen ના બિલિંગમાં, `total` એ global variable છે. એમાં ખોટી રકમ દેખાય છે. આ bug શોધવો કેમ અઘરો છે?
- 14 માંનું દરેક function total માં લખી શક્યું હોત, એટલે બધાં શંકાસ્પદ છે
- Global variables દશાંશ મૂલ્યો સંઘરી શકતાં નથી
- C ના programs debug કરી શકાતા નથી
- Bug main() માં જ હોવો જોઈએ, globals ફક્ત ત્યાં જ બદલાય છે
Show the answer
14 માંનું દરેક function total માં લખી શક્યું હોત, એટલે બધાં શંકાસ્પદ છે
Global data ને કોઈ માલિક નથી: કોઈ પણ function એને બદલી શકે છે, એટલે શોધનું ક્ષેત્ર આખો program છે. બરાબર એ જ પીડા OOP દૂર કરે છે, data ને object ને આપીને અને ફેરફાર ફક્ત એનાં member functions દ્વારા થવા દઈને. બીજા વિકલ્પો ખોટી માન્યતાઓ છે: globals કોઈ પણ પ્રકાર રાખે છે, C debug થઈ શકે છે, અને કોઈ પણ function (ફક્ત main નહીં) global લખી શકે છે.
Theory
તમે જે ચાર સ્તંભ ભણવાના છો
આ આખો વિષય OOP ના ચાર વિચાર ખોલે છે:
- Encapsulation: data વત્તા functions એક એકમમાં સીલ (station).
- Abstraction: counter દેખાડો, રસોડું છુપાવો.
- Inheritance: હયાત class માંથી નવો class બાંધો (Person ના card માંથી Student નું card).
- Polymorphism: એક call, અનેક વર્તન (એક
bill()જે students અને staff માટે જુદું discount આપે).
પછીનો દરેક વિષય આમાંનો એક સ્તંભ વિગતે છે.
Think first
એનું વર્ગીકરણ કરો
એક program માં addItem(), printBill(), applyDiscount() નાં functions છે, અને ત્રણેય એક global array menu[50] વાંચે અને લખે છે. Tap કરતાં પહેલાં: આ procedural છે કે object-oriented, અને કયો એક શબ્દ તમને કહી દે છે?
Show the answer
Procedural. ઓળખ આપતો શબ્દ છે global: data કોઈ પણ object ની બહાર વસે છે અને દરેક function એને સીધું પહોંચી શકે છે. Functions હોવાં એ કસોટી નથી (OOP પાસે પણ member functions છે). કસોટી છે data નો માલિક કોણ છે. OOP માં, menu class ની અંદર વસત અને ફક્ત એનાં member functions એને અડી શકત.
Watch out
ફાંદો: ".cpp" એટલે OOP નહીં
તમારો BCA104 શૈલીનો code .cpp થી પૂરી થતી file માં લખવાથી એ object-oriented બનતો નથી. C++ બંને શૈલી આપે છે, અને global data થી ભરેલું main() હજી procedural જ છે.
OOP એ રચનાની પસંદગી છે, file નો પ્રત્યય નહીં. પરીક્ષાઓને "શું C++ શુદ્ધ object-oriented છે?" પૂછવાનું ગમે છે. સલામત જવાબ: ના, C++ આંશિક રીતે OOP છે કારણ કે એ procedural code ને પણ ટેકો આપે છે (અને main() પોતે એક મુક્ત function છે).
Theory
Marks થી આગળ આ કેમ મહત્ત્વનું છે
તમે મળશો એ દરેક ગંભીર system (Java/Kotlin માં Android ની apps, Python માં Django, C++ માં game engines) object-oriented છે, કારણ કે 50 લોકોની ટીમો એક ખુલ્લું રસોડું વહેંચી શકતી નથી. જ્યારે મુલાકાત લેનાર પૂછે "OOP કેમ?", ત્યારે જીતતો જવાબ મોટા પાયે જાળવણીયોગ્યતા વિશે છે: bugs program ભરમાં ફેલાવાને બદલે એક class ની અંદર રહે છે.
Summary
Key takeaways
- Procedural programming = વહેંચાયેલા કે global data પર કામ કરતાં functions, ઉપરથી નીચેની રચના (C).
- OOP = એવા objects જે data ને એને અડવાની છૂટવાળાં member functions સાથે બાંધે છે, નીચેથી ઉપરની રચના (C++).
- Global data ને કોઈ માલિક નથી, એટલે એ બગડે ત્યારે દરેક function શંકાસ્પદ છે; OOP data ને માલિક આપે છે.
- આગળ ચાર સ્તંભ: encapsulation, abstraction, inheritance, polymorphism.
- C++ શુદ્ધ OOP નથી: એ ખુશીથી procedural code પણ ચલાવે છે, OOP એ રચનાની પસંદગી છે.
- Memory hook: ખુલ્લું રસોડું સામે counter વાળાં stations.