Intermediate LevelOOP & CLASSES · C++ TrackCompiler: g++ -std=c++20 -O2
C++ Object-Oriented Programming (OOP)
Classes, encapsulation, constructor overloading, copy constructors, and object comparison functions.
Exercises:18 Practice Labs
All C++ ModulesOOP Coding Labs (18)Click any card to start in laboratory
Lab #01 · Object-Oriented Programming
Medium15 mins
OOP Lab 01: Product Class & Discount System
Implement a Product class with constructor overloading, copy constructor, discount computation, and non-negative price enforcement.
Objective: Implement a `Product` class with private attributes `productID` (int), `price` (double), and `discount` (double percentage).
1. Provide constructor overloading: one constructor taking only `(int id, double price)` (defaulting discount to 0.0), and another taking `(int id, double price, double discount)`.
2. Implement a copy constructor `Product(const Product& other)` that duplicates product state.
3. Implement `applyDiscount()` which calculates the discount and updates the price, ensuring the final price never drops below 0.
4. Implement `getFinalPrice() const` returning the current price, and `display() const` showing product details.
5. In `main()`, instantiate products using both constructors, copy a product, apply discounts, and display results before and after.
Interactive SandboxStart Lab
Lab #02 · Object-Oriented Programming
Medium15 mins
OOP Lab 02: Patient Admission & Bill Comparison
Design a Patient class with default daily charges, bill calculation with discounts, input validation, and standalone comparison function.
Objective: Implement a `Patient` class with private attributes: `patientID` (int), `daysAdmitted` (int), and `dailyCharge` (double).
1. Provide a constructor with default daily charge: `Patient(int id, int days, double charge = 500.0)`.
2. Validate inputs: ensure `daysAdmitted` and `dailyCharge` cannot be negative (set to 0 or 500 if negative).
3. Implement `calculateBill(int discount = 0)` that returns `(daysAdmitted * dailyCharge) - discount`, ensuring the total never drops below 0.
4. Implement a standalone function `Patient compareBills(Patient p1, Patient p2)` that calculates the bill for both and returns the `Patient` object with the higher bill.
5. In `main()`, instantiate patients, compute bills with and without discounts, and find the highest bill using `compareBills`.
Interactive SandboxStart Lab
Lab #03 · Object-Oriented Programming
Medium15 mins
OOP Lab 03: Ticket Booking & Category Pricing
Implement a Ticket reservation class with category markups ('S', 'P', 'V'), tax calculation, and standalone ticket comparison.
Objective: Implement a `Ticket` class with private attributes: `ticketID` (int), `basePrice` (double, default 10.0), and `category` (char: 'S', 'P', or 'V').
1. Provide overloaded constructor `Ticket(int id, char cat = 'S', double price = 10.0)`.
2. Implement category pricing adjustments:
- 'S' (Standard): Base price remains unchanged (+0%).
- 'P' (Premium): 30% markup (`price * 1.30`).
- 'V' (VIP): 50% markup (`price * 1.50`).
3. Implement `calculateFinalPrice(double tax = 5.0)` returning category-adjusted price plus fixed tax.
4. Implement standalone function `Ticket compareTickets(Ticket t1, Ticket t2)` returning the `Ticket` with the higher final price.
5. In `main()`, create tickets for different tiers, calculate final prices with default/custom tax, and compare them.
Interactive SandboxStart Lab
Lab #04 · Object-Oriented Programming
Medium15 mins
OOP Lab 04: Flight Reservation & Capacity Guard
Manage airline seats, handle ticket bookings with overbooking constraints, and compare flight fares.
Objective: Implement a `Flight` class to manage airline bookings with private attributes: `flightID` (int), `availableSeats` (int, default 100), and `fare` (double, default 500.0).
1. Provide a constructor `Flight(int id, int seats = 100, double flightFare = 500.0)`.
2. Implement `bookTicket(int count = 1)`:
- Guard against negative booking counts or 0.
- Prevent overbooking: if `count > availableSeats`, display an error and reject the booking (return false).
- If valid, decrement `availableSeats` by `count` and return true.
3. Implement standalone function `Flight compareFare(Flight f1, Flight f2)` returning the `Flight` object with the **cheaper (lower) fare**.
4. In `main()`, instantiate flights, book tickets (testing both successful and overbooking scenarios), and find the cheaper flight.
Interactive SandboxStart Lab
Lab #05 · Object-Oriented Programming
Medium15 mins
OOP Lab 05: Student Grading & Performance Evaluation
Compute weighted academic marks, cap scores at 100, validate input ranges, and compare top students.
Objective: Implement a `Student` class for grading evaluation with private attributes: `studentID` (int), `midtermMarks` (double), `finalMarks` (double), and `assignmentMarks` (double).
1. Provide a default constructor initializing all marks to 0.0, and a parameterized constructor `Student(int id, double mid, double fin, double assign)`.
2. Validate all marks during creation to ensure they lie within the range `[0, 100]`.
3. Implement `calculateGrade(double bonus = 0.0)` that computes the weighted grade:
`total = (midtermMarks * 0.30) + (finalMarks * 0.50) + (assignmentMarks * 0.20) + bonus`
Ensure the calculated grade is capped at a maximum of `100.0`.
4. Implement standalone function `Student compareStudents(Student s1, Student s2)` returning the `Student` object with the higher calculated grade.
5. In `main()`, create student objects, calculate grades with/without bonus, and determine the top performer.
Interactive SandboxStart Lab
Lab #06 · Object-Oriented Programming
Hard18 mins
OOP Lab 06: Autonomous Drone & Deep Copy Dynamic Memory
Implement an autonomous delivery Drone class with dynamically allocated coordinate and velocity vectors, verifying deep copy isolation.
Objective: Define a `Drone` class to represent an autonomous delivery drone:
1. **Private Data Members**:
- `position` (`double*`): Dynamically allocated array of size 3 representing `[x, y, z]` coordinates in meters.
- `speed` (`double*`): Dynamically allocated array of size 3 representing velocity components `[vx, vy, vz]` in m/s.
- `batteryLevel` (`double`): Current battery percentage (0.0 to 100.0).
2. **Constructors & Destructor**:
- Parameterized constructor `Drone(double x, double y, double z, double vx, double vy, double vz, double battery)` allocating `new double[3]` for both `position` and `speed`.
- **Copy Constructor** `Drone(const Drone& other)` implementing **deep copy** (allocates new memory and copies values).
- Destructor `~Drone()` deallocating dynamic memory with `delete[]`.
3. **Methods**:
- `displayStatus() const`: Prints position `(x, y, z)`, velocity `(vx, vy, vz)`, and battery percentage.
- `setPosition(double x, double y, double z)`: Updates coordinates.
- `setBatteryLevel(double battery)`: Updates battery.
4. **In `main()`**:
- Create a `Drone` object representing an active drone in transit.
- Create a copy using the copy constructor.
- Modify the copied instance (change position and battery) and verify the original remains unaffected (deep copy verified).
Interactive SandboxStart Lab
Lab #07 · Object-Oriented Programming
Hard18 mins
OOP Lab 07: Vehicle Fleet Management & Static Tracking
Design a Vehicle fleet system with immutable registration numbers, static aggregation counters, and formatted file reporting.
Objective: Design a `Vehicle` class to manage a corporate delivery fleet:
1. **Data Members**:
- `const std::string registrationNumber`: Assigned during construction (immutable).
- `std::string modelName`: Vehicle model name.
- `double rentalCostPerDay`: Daily rental cost.
- `static int totalVehicles`: Static counter tracking total fleet vehicles.
- `static double totalExpenditure`: Static accumulator tracking sum of daily rental costs.
2. **Constructors & Static Methods**:
- Parameterized constructor initializing `registrationNumber` using a member initializer list, and updating `totalVehicles` and `totalExpenditure`.
- Static functions `static int getCount()` and `static double getExpenditure()`.
- Getters for attributes.
3. **Reporting Function**:
- Implement `void writeDetails(const Vehicle& v)` that formats vehicle info for reporting.
4. **In `main()`**:
- Instantiate multiple `Vehicle` objects.
- Display individual vehicle reports and print aggregated fleet summary statistics.
Interactive SandboxStart Lab
Lab #08 · Object-Oriented Programming
Medium15 mins
OOP Lab 08: Student Records, Static Metrics & Object Pointers
Manage student records with default arguments, static cohort counters, department filtering, and pointer traversal.
Objective: Create a `Student` class for university cohort tracking:
1. **Private Data Members**:
- `studentID` (`int`): Unique roll number.
- `name` (`std::string`): Student name.
- `department` (`std::string`): Academic department (e.g. "CS", "SE", "EE").
- `CGPA` (`double`): Cumulative grade point average.
- `static int totalStudents`: Tracks total instantiated student records.
2. **Constructors & Methods**:
- Constructor with default arguments: `Student(int id = 0, std::string name = "Unknown", std::string dept = "General", double cgpa = 0.0)` incrementing `totalStudents`.
- Static function: `static int getTotalStudents()`.
- Constant member functions: `getCGPA() const`, `getDepartment() const`, `getName() const`, `getStudentID() const`.
- `display() const`: Prints formatted record.
3. **In `main()`**:
- Instantiate an array of `Student` objects.
- Display total cohort count via static function.
- Filter and display students belonging to a specified department using an object pointer `Student* ptr`.
Interactive SandboxStart Lab
Lab #09 · Object-Oriented Programming
Medium15 mins
OOP Lab 09: Book Inventory & Transaction Guard
Build a bookstore inventory system with stock validation, purchase transaction limits, and bulk-buying prevention.
Objective: Implement a `Book` class for a bookstore inventory system:
1. **Private Attributes**:
- `bookID` (`int`): Unique identifier.
- `title` (`std::string`): Title of the book.
- `price` (`double`): Price per single copy.
- `stock` (`int`): Available inventory copies.
2. **Constructors & Methods**:
- Parameterized constructor: `Book(int id, std::string t, double p, int s)`.
- Method `purchase(int quantity)`:
- **Bulk purchase limit**: If `quantity > 5`, print error `"[!] Bulk purchase limit exceeded (Max 5 copies per transaction)"` and return `false`.
- **Stock validation**: If `quantity > stock`, print error `"[!] Insufficient stock available"` and return `false`.
- **Non-positive quantity**: If `quantity <= 0`, print error `"[!] Invalid purchase quantity"` and return `false`.
- On successful validation: Deduct `stock -= quantity`, print confirmation and total cost, and return `true`.
- `display() const`: Prints book ID, title, unit price, and current stock.
3. **In `main()`**:
- Create an array of `Book` objects representing store catalog.
- Test valid purchases, bulk limit exceed attempts (> 5), and insufficient stock attempts.
- Display updated catalog stock after transactions.
Interactive SandboxStart Lab
Lab #10 · Object-Oriented Programming
Medium15 mins
OOP Lab 10: Course Enrollment System (Pointer Association)
Model a university enrollment system using pointer-based association between Student and Course classes.
Objective: Model a University Course Enrollment System using pointer-based association between `Student` and `Course`:
1. **Course Class**:
- Attributes: `courseID` (std::string), `title` (std::string), `creditHours` (int).
- Constructor to initialize attributes.
- Methods: `getTitle() const`, `getCreditHours() const`, `displayCourseDetails() const`.
2. **Student Class**:
- Attributes: `studentID` (int), `name` (std::string), `Course* enrolledCourses[5]` (array of Course pointers), `int courseCount`.
- Constructor initializing student ID and name, setting `courseCount = 0`.
- Method `enrollInCourse(Course* c)`: Adds course pointer if `courseCount < 5`.
- Method `displayEnrolledCourses() const`: Iterates through stored pointers, calls `displayCourseDetails()`, and prints total credit hours.
3. **In `main()`**:
- Create multiple `Course` objects.
- Create a `Student` and enroll in courses by passing pointers `&course`.
- Display all enrolled courses and total credits.
Interactive SandboxStart Lab
Lab #11 · Object-Oriented Programming
Hard18 mins
OOP Lab 11: Dynamic Order System (Dynamic Aggregation)
Simulate a Customer-Order placement system using dynamic memory allocation, array expansion, and linked order aggregation.
Objective: Simulate an Order Placement System where a Customer manages dynamically allocated Orders:
1. **Order Class**:
- Attributes: `orderID` (int), `productName` (std::string), `quantity` (int), `price` (double).
- Methods: `displayOrderDetails() const`, `getTotalPrice() const` returning `quantity * price`.
2. **Customer Class**:
- Attributes: `customerID` (int), `customerName` (std::string), `Order* orders` (dynamic heap array), `int orderCount`, `int capacity`.
- Constructor allocating initial heap capacity and setting `orderCount = 0`.
- Destructor `~Customer()` deallocating dynamic memory with `delete[] orders`.
- Method `addOrder(const Order& order)` with capacity expansion.
- Method `displayOrders() const` printing order details and grand total expenditure.
3. **Global Link Function**:
- `void linkOrderToCustomer(Customer* cust, const Order& order)` calling `cust->addOrder(order)`.
4. **In `main()`**:
- Create a `Customer` and multiple `Order` objects.
- Associate orders using `linkOrderToCustomer()` and display billing summary.
Interactive SandboxStart Lab
Lab #12 · Object-Oriented Programming
Hard20 mins
OOP Lab 12: Library & Librarian System (Multi-Class Aggregation)
Implement a 3-class library catalog with Member, Book, and Librarian classes communicating through object aggregation.
Objective: Model a Library Management System using multi-class aggregation across `Book`, `Member`, and `Librarian`:
1. **Book Class**:
- Attributes: `bookID` (int), `title` (std::string), `author` (std::string), `isAvailable` (bool, default true).
- Methods: `setAvailability(bool status)`, `getAvailability() const`, `display() const`, `getTitle() const`.
2. **Member Class**:
- Attributes: `memberID` (int), `name` (std::string), `Book* borrowedBooks[3]` (pointers), `int borrowedCount`.
- Methods: `borrowBook(Book* b)` (marks book unavailable), `returnBook(Book* b)`, `displayBorrowedBooks() const`.
3. **Librarian Class**:
- Attributes: `librarianID` (int), `name` (std::string), `Book* catalog[10]`, `int catalogSize`.
- Methods: `addBookToCatalog(Book* b)`, `displayAvailableBooks() const`.
4. **In `main()`**:
- Create books and add to `Librarian` catalog.
- Member borrows available books, catalog updates availability status, and member returns a book.
Interactive SandboxStart Lab
Lab #13 · Object-Oriented Programming
Medium15 mins
OOP Lab 13: Mentorship System (Aggregation vs Composition)
Demonstrate OOP Aggregation where a Teacher class manages an array of Student object pointers with decoupled lifecycles.
Objective: Model an Academic Mentorship System using pointers as data members inside the `Teacher` class:
1. **Student Class**:
- Attributes: `studentID` (int), `name` (std::string), `cgpa` (double).
- Const member functions: `getStudentName() const`, `getStudentID() const`, `getCGPA() const`.
- Method `display() const`: Prints student roll number, name, and CGPA.
2. **Teacher Class**:
- Attributes: `teacherID` (int), `name` (std::string), `department` (std::string), `Student* students[5]` (array of pointers), `int numStudents`.
- Constructor initializing teacher attributes and setting `numStudents = 0`.
- Method `assignStudents(Student* s[], int n)`: Populates internal pointer array with `n` student addresses.
- Method `displayMentorship() const`: Displays teacher info and all assigned students.
3. **Aggregation Principle**:
- Students exist independently; deleting/scope-exiting a Teacher does not destroy the Student objects.
4. **In `main()`**:
- Create student objects.
- Create teacher objects and associate student pointer arrays.
- Display mentorship assignments.
Interactive SandboxStart Lab
Lab #14 · Object-Oriented Programming
Medium15 mins
OOP Lab 14: School & Schedule System (Pure OOP Composition)
Demonstrate strong Composition where a School object directly owns and manages its embedded Schedule object lifecycle.
Objective: Model a School and its Timetable Schedule using pure OOP Composition (Has-A Strong Ownership):
1. **Schedule Class**:
- Attributes: `schoolDay` (std::string), `startTime` (std::string), `endTime` (std::string), `std::string subjects[4]`, `int subjectCount`.
- Constructor initializing timings and subjects.
- Method `displaySchedule() const`: Displays timings and subject list.
2. **School Class**:
- Attributes: `schoolID` (int), `schoolName` (std::string), `Schedule timetable` (embedded object, strong composition).
- Constructor: `School(int id, std::string name, Schedule s)` initializing members via member initializer list.
- Method `displaySchoolDetails() const`: Prints school metadata and calls `timetable.displaySchedule()`.
3. **Composition Principle**:
- Strong ownership: The `Schedule` object is owned directly by the `School` object; their lifetimes are bound together.
4. **In `main()`**:
- Create a `Schedule` object with daily subjects.
- Instantiate a `School` object embedding the schedule.
- Call `displaySchoolDetails()`.
Interactive SandboxStart Lab
Lab #15 · Object-Oriented Programming
Medium15 mins
OOP Lab 15: ComplexNumber Class Arithmetic Operators
Overload arithmetic operators (+, -, *, /) for a ComplexNumber class in real + imag * i form.
Objective: Create a `ComplexNumber` class to perform arithmetic operations with complex numbers in the form `realPart + imaginaryPart * i`:
1. **Data Members**:
- Private attributes: `double realPart`, `double imaginaryPart`.
- Constructor with default values: `ComplexNumber(double r = 0.0, double i = 0.0)`.
2. **Overloaded Operators**:
- Addition (`operator+`): `(a + bi) + (c + di) = (a + c) + (b + d)i`
- Subtraction (`operator-`): `(a + bi) - (c + di) = (a - c) + (b - d)i`
- Multiplication (`operator*`): `(a + bi) * (c + di) = (ac - bd) + (ad + bc)i`
- Division (`operator/`): `(a + bi) / (c + di) = [(ac + bd)/(c^2 + d^2)] + [(bc - ad)/(c^2 + d^2)]i`
3. **Display Method**:
- `display() const`: Prints the formatted complex number (e.g. `5.00 + 1.00i` or `3.00 - 5.00i`).
4. **In `main()`**:
- Instantiate complex numbers `c1(4.0, 3.0)` and `c2(1.0, -2.0)`.
- Compute and display results of `c1 + c2`, `c1 - c2`, `c1 * c2`, and `c1 / c2`.
Interactive SandboxStart Lab
Lab #16 · Object-Oriented Programming
Hard20 mins
OOP Lab 16: Matrix Class Dynamic Operators
Add dynamic operator overloading to a Matrix class: assignment (=), addition (+), subtraction (-), and matrix multiplication (*).
Objective: Add dynamic operator overloading functions to a 2D `Matrix` class:
1. **Data Members & Memory**:
- Private attributes: `int rows`, `int cols`, `int** data` (dynamically allocated 2D integer array).
- Parameterized constructor `Matrix(int r, int c)` allocating memory and initializing elements.
- Copy Constructor `Matrix(const Matrix& other)` performing deep copy.
- Destructor `~Matrix()` releasing dynamic 2D memory with `delete[]`.
2. **Overloaded Operators**:
- **Assignment** (`operator=`): Deep copy with self-assignment guard (`if (this != &other)`).
- **Addition** (`operator+`): Element-wise addition for equal dimensions.
- **Subtraction** (`operator-`): Element-wise subtraction for equal dimensions.
- **Multiplication** (`operator*`): Dot product matrix multiplication `(r1 x c1) * (c1 x c2) -> (r1 x c2)`.
3. **Display & Utility**:
- `set(int r, int c, int val)` and `display() const`.
4. **In `main()`**:
- Instantiate matrices A and B, set values, and demonstrate `A + B`, `A - B`, `A * B`, and assignment `C = A`.
Interactive SandboxStart Lab
Lab #17 · Object-Oriented Programming
Hard18 mins
OOP Lab 17: Custom CString Class Concatenation Operators
Implement custom string concatenation and compound assignment operators (=, +, +=) for both CString objects and raw C-strings.
Objective: Add dynamic operator overloading functions to a custom `CString` class managing dynamic heap character arrays:
1. **Data Members & Memory**:
- Private attributes: `char* buffer`, `int length`.
- Parameterized constructor `CString(const char* str = "")` allocating heap memory.
- Deep Copy Constructor `CString(const CString& other)`.
- Destructor `~CString()` releasing heap buffer with `delete[]`.
2. **Overloaded Operators**:
- **Assignment** (`operator=`):
- `CString& operator=(const CString& other)`
- `CString& operator=(const char* str)`
- **Concatenation** (`operator+`):
- `CString operator+(const CString& other) const`
- `CString operator+(const char* str) const`
- **Compound Concatenation** (`operator+=`):
- `CString& operator+=(const CString& other)`
- `CString& operator+=(const char* str)`
3. **In `main()`**:
- Demonstrate assignment, object concatenation (`s1 + s2`), string literal concatenation (`s1 + " World"`), and compound concatenation (`s1 += "!"`).
Interactive SandboxStart Lab
Lab #18 · Object-Oriented Programming
Hard20 mins
OOP Lab 18: Fraction Class Arithmetic, Relational & Unary Operators
Implement a reduced Fraction class with overloaded arithmetic (+, -, *, /), relational (==, !=, <, >, <=, >=), increment/decrement (++ / --), unary (-), and compound (+=, -=, *=, /=) operators.
Objective: Create a `Fraction` class to perform arithmetic and relational operations on rational numbers in reduced form:
1. **Data Members & Reduction**:
- Private attributes: `int numerator`, `int denominator`.
- Helper function `reduce()` using Greatest Common Divisor (`gcd`) ensuring denominator is positive and fraction is in irreducible form.
- Constructor `Fraction(int num = 0, int den = 1)`.
2. **Overloaded Operators**:
- **Arithmetic Operators**: `+`, `-`, `*`, `/`
- **Relational / Comparison Operators**: `==`, `!=`, `<`, `>`, `<=`, `>=`
- **Unary Minus**: `Fraction operator-() const` returning negative fraction.
- **Increment & Decrement**:
- Pre-increment `++f` and Post-increment `f++`
- Pre-decrement `--f` and Post-decrement `f--`
- **Compound Assignment**: `+=`, `-=`, `*=`, `/=`
3. **Display Method**:
- `display() const`: Prints fraction in `a/b` format.
4. **In `main()`**:
- Create fractions (e.g. `f1 = 1/2`, `f2 = 3/4`).
- Test arithmetic, relational comparisons, unary negation, pre/post increments, and compound assignments.
Interactive SandboxStart Lab