• Level 0 (Root): The entire problem statement

• Level 1: Major functional modules (3–5 modules)

• Level 2+: Refine each module into implementable tasks

• Stop condition: A task fits in ~10–30 lines within one function

string encrypt(string text, int shift) {
  string result = text;
  for (int i = 0; i < result.length(); i++) {
    if (isalpha(result[i])) {
      char base = isupper(result[i]) ? 'A':'a';
      result[i] = (result[i]-base+shift)%26+base;
    }
  }
  return result;
}

// Decrypt by reversing — REUSES encrypt()!
string decrypt(string text, int shift) {
  return encrypt(text, 26 - shift);
}

void tryToDouble(int x) {
  x = x * 2;  // Modifies LOCAL COPY only!
  cout << "Inside: x = " << x;  // 20
}

int main() {
  int num = 10;
  tryToDouble(num);  // Passes a COPY of num
  cout << "After: num = " << num; // Still 10!
}

Inside function: x = 20
After call: num = 10  ← Original unchanged!

Before call:
┌────────────────┐
│ main's num: 10 │
└────────────────┘
During tryToDouble():
┌────────────────┐
│ main's num: 10 │ (safe)
├────────────────┤
│ copy x:    20  │ (modified)
└────────────────┘
After return:
┌────────────────┐
│ main's num: 10 │
└────────────────┘
(copy destroyed)

• When the function should NOT modify the original data

• For small data types (int, double, char, bool) where copying is cheap

void actuallyDouble(int &x) {  // &x = alias
  x = x * 2;  // Modifies ORIGINAL directly!
  cout << "Inside: x = " << x;  // 20
}

int main() {
  int num = 10;
  actuallyDouble(num);
  cout << "After: num = " << num; // Now 20!
}

// Practical: Swapping Two Variables
void swap(int &a, int &b) {
  int temp = a;
  a = b;
  b = temp;
}
// swap(x, y) — x and y swapped in main()!

Before call:
┌────────────────┐
│ main's num: 10 │
└────────────────┘

During actuallyDouble():
┌────────────────┐
│ main's num: 20 │ ← &x
└────────────────┘
(x IS num — same memory cell)

After return:
┌────────────────┐
│ main's num: 20 │
└────────────────┘

• When the function MUST modify the original variable (e.g., swap, readInput)

• When passing large data structures to avoid expensive copying

void doubleViaPointer(int *ptr) {
  *ptr = (*ptr) * 2;  // Dereference to modify
  cout << "Inside: *ptr = " << *ptr;  // 20
}

int main() {
  int num = 10;
  doubleViaPointer(&num);  // Pass ADDRESS of num
  cout << "After: num = " << num;  // Now 20!
}

Inside function: *ptr = 20
After call: num = 20  ← Original IS modified!

Before call:
┌──────────────────┐
│ num: 10          │
│ Address: 0x1000  │
└──────────────────┘

During doubleViaPointer():
┌──────────────────┐
│ num: 20          │ ← *ptr writes here
│ Address: 0x1000  │
├──────────────────┤
│ ptr: 0x1000      │ (contains num's address)
└──────────────────┘

• Dynamic memory (new/delete) or arrays (decay to pointers)

• When you need to handle the nullptr case

• When interfacing with C libraries using pointer-based APIs

int globalCounter = 0; // GLOBAL
                       // accessible everywhere

void increment() {
    int localStep = 1; // LOCAL
                       // only inside increment()
    globalCounter += localStep; // OK ✓
}

int main() {
    int localVar = 100; // LOCAL
                        // only inside main()
    increment();
    cout << globalCounter; // OK ✓ (global)
    cout << localVar;      // OK ✓ (local here)
    // cout << localStep;  // ✗ ERROR!
                            // localStep not in scope
}

// Overload 1: Base price, no discount
double calcPrice(double price) {
  return price;
}

// Overload 2: Price with percentage discount
double calcPrice(double price, double discountPct) {
  return price * (1 - discountPct / 100);
}

// Overload 3: With maximum discount cap
double calcPrice(double price, double discountPct,
                 double maxDiscount) {
  double disc = price * discountPct / 100;
  return price - min(disc, maxDiscount);
}

• ✅ Different number of parameters → valid overload

• ✅ Different types of parameters → valid overload

• ❌ Different return type only → NOT a valid overload (compile error)

string names[100];     // Product name
double prices[100];    // Unit price
int quantities[100];   // Stock quantity

// To access Product #3:
cout << names[3] << " costs "
     << prices[3] << " VND";
// What if we use prices[4] with names[3]?
// → WRONG DATA!

• Index synchronization required — names[i], prices[i] must always match

• Adding a new field (e.g., category) = create a 4th array, update ALL functions

• Sorting requires swapping across all arrays simultaneously

// WITHOUT struct:
string names[100];
double prices[100];
int quantities[100];
string categories[100];
// 4 parallel arrays!

// WITH struct:
struct Product {
  string name;
  double price;
  int quantity;
  string category;
};
Product products[100];
// All data in ONE place!

struct StructName {
  DataType member1;
  DataType member2;
  DataType member3;
};  // ← Don't forget the semicolon!

struct Product {
  string name;      // Product name
  double price;     // Unit price
  int quantity;     // Stock quantity
  string category;  // Product category
};

struct Student {
  string id;        // "B21DCMM001"
  string fullName;  // Full name
  double gpa;       // Grade Point Average
  int credits;      // Total credits completed
};

• A struct definition creates a new data type (like int or double), not a variable

• Members can be of different types — string, int, double, even another struct

• ⚠️ The semicolon ; after the closing brace } is mandatory!

struct Date {
  int day;
  int month;
  int year;
};

struct Student {
  string id;
  string fullName;
  Date birthDate;   // Nested struct!
  double gpa;
};

// Usage:
Student s;
s.fullName = "Nguyen Van A";
s.birthDate.day = 15;
s.birthDate.month = 3;
s.birthDate.year = 2004;

struct Address {
  string street;
  string city;
  string zipCode;
};

struct Order {
  int orderId;
  Address sender;    // Nested!
  Address receiver;  // Nested!
  double totalWeight;
};

const int MAX = 100;
Product inventory[MAX];  // Array of 100 Products
int total = 0;

// Add products:
inventory[total] = {"Keyboard", 500000, 10, "Accessories"};
total++;
inventory[total] = {"Monitor", 3500000, 3, "Electronics"};
total++;

// Display all products:
for (int i = 0; i < total; i++) {
  cout << i+1 << ". "
       << inventory[i].name << " | "
       << inventory[i].price << " VND | Qty: "
       << inventory[i].quantity << endl;
}

inventory[0]
┌─────────────────────┐
│ name: "Keyboard"    │ Address: 0x1000
│ price: 500000       │
│ quantity: 10        │
│ category: "Access." │
└─────────────────────┘
inventory[1]
┌─────────────────────┐
│ name: "Monitor"     │ Address: 0x1050
│ price: 3500000      │
│ quantity: 3         │
│ category: "Electr." │
└─────────────────────┘

void sortByPrice(Product inv[], int n) {
  for (int i = 0; i < n - 1; i++) {
    for (int j = 0; j < n - i - 1; j++) {
      if (inv[j].price > inv[j+1].price) {
        swap(inv[j], inv[j+1]); // Swap entire structs
      }
    }
  }
}
// Sort by name (alphabetical)
void sortByName(Product inv[], int n) {
  for (int i = 0; i < n - 1; i++) {
    for (int j = 0; j < n - i - 1; j++) {
      if (inv[j].name > inv[j+1].name) {
        swap(inv[j], inv[j+1]);
      }
    }
  }
}

string names[100];
double prices[100];
int quantities[100];

struct Product {
  string name;
  double price;
  int quantity;
};
Product inventory[MAX];

// 4 Function Prototypes:
void printProduct(const Product &p, int index);
void addProduct(Product inv[], int &total);
void displayAll(const Product inv[], int total);
void searchProduct(const Product inv[], int total,
                   string keyword);

#include <iostream>
#include <limits>
#include <string>
using namespace std;

// Struct dinh nghia kieu du lieu San pham
struct Product {
  string name;
  double price;
  int quantity;
};

const int MAX = 100;

// Khai bao nguyen mau ham (Function Prototypes)
void printProduct(const Product &p, int index);
void addProduct(Product inv[], int &total);
void displayAll(const Product inv[], int total);
void searchProduct(const Product inv[],
                   int total, string keyword);

// 1. Ham them san pham (truyen tham chieu int &total de cap nhat so luong tong)
void addProduct(Product inv[], int &total) {
  if (total < MAX) {
    cin.ignore(numeric_limits::max(), '\n');

    cout << "Ten SP: ";
    getline(cin, inv[total].name);

    do {
      cout << "Gia (>0): ";
      cin >> inv[total].price;
    } while (inv[total].price <= 0);

    do {
      cout << "SL (>0): ";
      cin >> inv[total].quantity;
    } while (inv[total].quantity <= 0);

    total++;

    cout << "=> Them thanh cong!\n";
  } else {
    cout << "MANG DA DAY!\n";
  }
}

// Ham ho tro in thong tin 1 san pham (Dung chung cho Hien thi & Tim kiem)
void printProduct(const Product &p, int index) {
  cout << index << ". " << p.name << " | Gia: " << p.price
       << " | SL: " << p.quantity << endl;
}

// 2. Ham hien thi danh sach san pham (Read-only)
void displayAll(const Product inv[], int total) {
  cout << "\n--- DANH SACH SAN PHAM ---\n";
  if (total == 0) {
    cout << "Chua co san pham nao.\n";
  } else {
    for (int i = 0; i < total; i++) {
      printProduct(inv[i], i + 1);
    }
  }
}

// 3. Ham tim kiem san pham theo ten (Read-only)
void searchProduct(const Product inv[], int total, string keyword) {
  bool found = false;
  cout << "\n--- KET QUA TIM KIEM ---\n";
  for (int i = 0; i < total; i++) {
    if (inv[i].name.find(keyword) != string::npos) {
      printProduct(inv[i], i + 1);
      found = true;
    }
  }
  if (!found) {
    cout << "Khong tim thay san pham.\n";
  }
}

int main() {
  Product inventory[MAX];
  int total = 0;
  int choice;

  do {
    cout << "\n===== MINIPOS V2.0.0 =====\n";
    cout << "1. Them san pham\n";
    cout << "2. Hien thi danh sach\n";
    cout << "3. Tim kiem\n";
    cout << "0. Thoat\n";
    cout << "Chon: ";

    cin >> choice;
    switch (choice) {

    case 1:
      addProduct(inventory, total);
      break;
    case 2:
      displayAll(inventory, total);
      break;
    case 3: {
      cin.ignore(numeric_limits<streamsize>::max(), '\n');
      string keyword;
      cout << "Nhap ten san pham can tim: ";
      getline(cin, keyword);
      searchProduct(inventory, total, keyword);
      break;
    }

    case 0:
      cout << "Dang thoat chuong trinh...\n";
      break;

    default:
      cout << "Lua chon khong hop le!\n";
    }
  } while (choice != 0);
  return 0;
}

struct Product { string name; double price; };
void display(const Product &p) {
  cout << p.name << ": " << p.price;
}
display(laptop);

class Product {
private:
 string name; double price;
public:
 void display() {
 cout << name << ": " << price;
 }
};
laptop.display(); // Object "knows" how to display!