Object Oriented Programming
Fee: 8,000 /- PKR (per-month)
Registration Fee: 1,000 /- PKR
(non-refundable)
- Duration: 4.5 Months
- Starting: 26 January 2026
- Mode: Physical
- Days: Tuesday & Thursday
- Timing: 04:00 PM - 05:30 PM
- Location: ITU 6th Floor Arfa Tower
In Collaboration with Information Technology University (ITU)
Who can join this course?
If you're at the beginning of a BS degree in Computer Science, Software Engineering, Data Science, Machine Learning, or Artificial Intelligence at any university or affiliated college in Lahore or its vicinity, this is an excellent opportunity to build a strong foundation for your journey in this field.
About Course
Object Oriented Programming is a comprehensive one-semester course that strengthens students’ foundations in C++ programming while introducing core Object-Oriented Programming (OOP) concepts. The course begins with a revision of arrays, pointers, and structs, then gradually moves into classes, encapsulation, constructors, inheritance, polymorphism, and operator overloading. Students gain hands-on experience through real-world projects such as a text editor, calculator, chess game, and huge integer system, along with STL-based data structures and template programming. The course also covers debugging techniques, memory management, exception handling, and software design principles.
By the end of the semester, learners develop strong problem-solving skills, write well-structured OOP code, and understand how to design scalable and efficient software systems.
With lifetime access to our lecture content,
Course Outline
Lecture 1: Revising the Foundations with Arrays
Build confidence with basic data handling in C++
• What are arrays and why they are used
• Initialization and randomization
• Searching (linear & binary)
• Sorting (bubble, insertion, selection)
• Two-pointer techniques
• Frequency & statistics problems
Lecture 2: Mastering 2D Arrays
Work with matrix-style data
• 2D array initialization methods
• File & user input
• Traversal techniques
• Row/column sorting
• Matrix operations
Lecture 3: Debugging & Path Finding
Learn smart debugging and grid algorithms
• Using breakpoints & watches
• Maze path finding (S → E)
• Ripple search for shortest paths
• Number of islands problem
• Flood prevention simulation
Lecture 4: Pointers Revisited
Understand memory and addresses
• Pointer basics & initialization
• Pointer arithmetic
• Pointers with arrays & functions
• Dynamic memory (new/delete)
Lecture 5: Structs & Function Pointers
Work with structured data
• Struct memory layout
• 2D dynamic arrays
• Shallow vs deep copy
• Function pointers
Lecture 6: Game Development with Raylib(Tutorial)
Build a real game loop
• Window setup & FPS
• Keyboard input
• Random spawning
• Collision detection
• Score system
Lecture 7: Introduction to Classes
Move from structs to OOP
• Time class design
• Private vs public
• Constructors
• Data encapsulation
Lecture 8: String Class Implementation
Build your own string system
• Constructors & destructor
• Deep vs shallow copy
• Operator overloading []
• stoi & itos
• Trim functions
Lecture 9: OOP & Human Body Analogy
Understand OOP conceptually
• History of programming
• Human body as OOP system
• Real-world OOP examples
Lecture 10: Polynomial Class
Work with mathematical objects
• Dynamic memory
• Add, subtract, multiply
• Long division
• File-based input
Lecture 11: Vectors & Set Class
Students use vectors to build a custom set data structure.
- C++: STL vector, find(), erase()
- Python: Lists & sets
Lecture 12: Text Editor
Students build a console-based text editor with navigation and editing features.
- C++: Cursor control, vectors of pointers
- Python: Text processing
Lecture 13: Text Editor & its Implementation
Students build a console-based text editor with navigation and editing features.
- C++: Cursor control, vectors of pointers
- Python: Text processing
Lecture 14: Class Dependencies & Memory
Students learn safe object relationships and deep copying.
- C++: Forward declarations, static members
- Python: Reference management
Lecture 15: Object Relationships
Students study composition, aggregation, and association.
- C++: Object linking
- Python: Class relationships
Lecture 16: Dynamic Sorted Array
Students implement a sorted container with operator overloading.
- C++: Dynamic arrays, destructor
- Python: Sorted lists
Lecture 17: Inheritance & GUI Calculator
Students build a Windows Form calculator using inheritance.
- C++:Inheritance, GUI events
- Python: GUI basics
Lecture 18: Polymorphism
Students use virtual functions for dynamic behavior.
- C++: Base pointers, virtual methodst
- Python: Method overriding
Lecture 19: OOP Design/Chess Project
Students learns Pure Virtual Functions and Abstract classes and Multiple Inheritance Issue
- C++: Abstract classes, rules
- Python: Game logic
Lecture 20: The Game of Chess (Phase 1)
Students will implement movement legality, six utility functions (IsHorizontalMove, IsVerticalMove, IsDiagonalMove and their 3 respective path clear functions). Later using those 6 functions build every piece-specific checks (IsRookLegalMove, IsQueenLegalMove), a unified LEGALITYCHECK, and memory diagrams for board state.
- C++: Function-based checks with pointer-driven board state
- Python: Class-based pieces with modular validation functions
Lecture 21: The Game of Chess (Phase 2)
Students will implement pawn promotion, save & exit, replay, undo, restart without saving, check, castling, checkmate, stalemate rules, and detect illegal moves (including those leaving the king in check). Integration of all modules, memory mapping, pointers, and dynamic state ensures a fully functional system.
- C++: Pointer-based memory management, manual save/load, and dynamic state tracking
- Python: State management, serialization-based save/load, and undo/replay handling
Lecture 22: Operator Overloading
Students customize operators for user-defined types.
- C++: +, ==, [], <<
- Python: Magic Methods
Lecture 23: Huge Integers Part I
Students work with large numbers using Operator overloading in huge integers for inputting and displaying the huge integers
- C++: Big integer arithmetic
- Python: Large integers
Lecture 24: Huge Integers Part II
Students will do quantity-wise addition quantity-wise subtraction of huge integers
- C++: Big integer arithmetic
- Python: Large integers
Lecture 25: Templates
Students will write generic code using templates.
- C++: Class & function templates
- Python: Generic functions
Lecture 26: Introduction to STL Data
Students will learn to use professional containers and iterators.
- C++: map, set, vector, iterators
- Python: Dicts,sets
Lecture 27: STL Data Structures
Students will use STL containers like Stcck,Queue,Map
- C++: map, set, vector, iterators
- Python: Dicts,Sets
Lecture 28: Exception Handling
Students learn safe error handling.
- C++: try-catch, exception classes
- Python: try-except