🎓 Danh sách khóa học Thầy Lê Chí Tuyền

// Chương trình C++ đầu tiên.
// Biên dịch:  g++ -std=c++17 01-hello.cpp -o hello
// Chạy:       ./hello        (Windows: hello.exe)

#include <iostream>     // chỉ thị tiền xử lý: chèn thư viện vào/ra (cout, cin)

/*
   Chú thích nhiều dòng.
   Mọi chương trình C++ bắt đầu chạy từ hàm main().
*/
int main() {
    std::cout << "Xin chào, C++!" << std::endl;   // in ra màn hình rồi xuống dòng

    // Mỗi câu lệnh kết thúc bằng dấu chấm phẩy ;
    // Khối lệnh được bao bởi cặp ngoặc nhọn { }
    int namHoc = 2026;
    std::cout << "Năm học: " << namHoc << "\n";

    std::cout << "C++ chạy trên: máy tính, Arduino, ESP32, STM32..." << '\n';

    return 0;   // 0 = chương trình kết thúc thành công
}

// Kiểu dữ liệu cơ bản và kiểu số nguyên cố định độ rộng (rất quan trọng trong lập trình nhúng)
#include <cstdint>
#include <iostream>
#include <limits>

int main() {
    std::cout << "== Kích thước (byte) trên máy này ==\n";
    std::cout << "bool   : " << sizeof(bool)   << "\n";
    std::cout << "char   : " << sizeof(char)   << "\n";
    std::cout << "short  : " << sizeof(short)  << "\n";
    std::cout << "int    : " << sizeof(int)    << "   (Arduino Uno: 2 byte!)\n";
    std::cout << "long   : " << sizeof(long)   << "\n";
    std::cout << "float  : " << sizeof(float)  << "\n";
    std::cout << "double : " << sizeof(double) << "   (Arduino Uno: 4 byte!)\n";

    std::cout << "\n== Kiểu cố định độ rộng <cstdint> – giống nhau trên mọi vi điều khiển ==\n";
    std::cout << "uint8_t  : 0 .. " << +std::numeric_limits<uint8_t>::max() << "\n";   // dấu + để in số, không in ký tự
    std::cout << "int8_t   : " << +std::numeric_limits<int8_t>::min() << " .. " << +std::numeric_limits<int8_t>::max() << "\n";
    std::cout << "uint16_t : 0 .. " << std::numeric_limits<uint16_t>::max() << "\n";
    std::cout << "int16_t  : " << std::numeric_limits<int16_t>::min() << " .. " << std::numeric_limits<int16_t>::max() << "\n";
    std::cout << "uint32_t : 0 .. " << std::numeric_limits<uint32_t>::max() << "\n";

    std::cout << "\n== Tràn số (overflow) ==\n";
    uint8_t dem = 255;
    dem = dem + 1;                       // 8 bit không chứa nổi 256 -> quay vòng về 0
    std::cout << "uint8_t 255 + 1 = " << +dem << "\n";
    uint16_t adc = 4095;                 // ADC 12 bit của ESP32 tối đa 4095
    std::cout << "ADC 12 bit tối đa: " << adc << " (vừa trong uint16_t)\n";

    std::cout << "\n== Số thực có sai số ==\n";
    double a = 0.1 + 0.2;
    std::cout.precision(17);
    std::cout << "0.1 + 0.2 = " << a << "\n";
    std::cout << "a == 0.3 ? " << std::boolalpha << (a == 0.3) << "  -> đừng so sánh số thực bằng ==\n";

    std::cout << "\n== Ký tự là một số ==\n";
    char c = 'A';
    std::cout << "'A' có mã ASCII " << int(c) << ", 'A' + 2 = " << char(c + 2) << "\n";
    bool denBat = true;
    std::cout << "bool true in ra: " << std::noboolalpha << denBat << "\n";
}

// Biến, phạm vi biến, hằng số, literal và modifier
#include <cstdint>
#include <iostream>

int soLanKhoiDong = 0;                    // biến TOÀN CỤC: sống suốt chương trình, mọi hàm thấy được

const int LED_PIN = 13;                   // hằng: không thể gán lại
constexpr uint32_t BAUD = 115200;         // hằng tính lúc BIÊN DỊCH
constexpr int TONG_CHAN = 2 * 20 + 4;     // biểu thức hằng – trình biên dịch tính sẵn = 44

void tangBien() {
    int cucBo = 0;                        // biến CỤC BỘ: tạo mới mỗi lần gọi hàm
    cucBo++;
    soLanKhoiDong++;
    std::cout << "  cucBo = " << cucBo << ", soLanKhoiDong = " << soLanKhoiDong << "\n";
}

int main() {
    std::cout << "== Phạm vi biến ==\n";
    tangBien();
    tangBien();

    int x = 10;
    {                                      // khối lệnh mới = phạm vi mới
        int x = 99;                        // biến che (shadow) x bên ngoài – nên tránh!
        int y = 5;
        std::cout << "  trong khối: x = " << x << ", y = " << y << "\n";
    }
    // std::cout << y;                     // LỖI: y đã ra khỏi phạm vi
    std::cout << "  ngoài khối: x = " << x << "\n";

    std::cout << "\n== Hằng ==\n";
    std::cout << "  LED_PIN = " << LED_PIN << ", BAUD = " << BAUD << ", TONG_CHAN = " << TONG_CHAN << "\n";
    // LED_PIN = 2;                        // LỖI biên dịch: không gán được hằng

    std::cout << "\n== Literal (cách viết hằng số) ==\n";
    int thapPhan = 255;
    int thapLucPhan = 0xFF;                // hệ 16 – hay dùng cho thanh ghi, mã màu
    int nhiPhan = 0b11111111;              // hệ 2 (C++14) – dễ nhìn từng bit
    int batPhan = 0377;                    // hệ 8 – số 0 đứng đầu! dễ nhầm
    std::cout << "  255 = 0xFF = 0b11111111 = 0377 ? "
              << (thapPhan == thapLucPhan && thapLucPhan == nhiPhan && nhiPhan == batPhan) << "\n";
    unsigned long trieu = 1'000'000UL;     // dấu ' phân cách chữ số (C++14), hậu tố UL
    float pi = 3.14159f;                   // hậu tố f = float
    std::cout << "  trieu = " << trieu << ", pi = " << pi << ", ký tự xuống dòng '\\n', tab '\\t'\n";

    std::cout << "\n== Modifier: signed / unsigned / short / long ==\n";
    unsigned int u = 0;
    u = u - 1;                             // không âm được -> quay vòng thành số rất lớn
    std::cout << "  unsigned 0 - 1 = " << u << "\n";
    signed char sc = -128;
    short s = 32767;
    long long ll = 9'000'000'000LL;
    std::cout << "  signed char = " << int(sc) << ", short = " << s << ", long long = " << ll << "\n";

    std::cout << "\n== auto: để trình biên dịch tự suy ra kiểu ==\n";
    auto nhietDo = 28.5;                   // double
    auto soCamBien = 4;                    // int
    std::cout << "  sizeof(nhietDo) = " << sizeof(nhietDo) << ", sizeof(soCamBien) = " << sizeof(soCamBien) << "\n";
}

// Lớp lưu trữ (storage class): auto, static, extern, mutable, thread_local – và từ khoá volatile
#include <iostream>

// static ở phạm vi file: biến/hàm chỉ thấy được trong file .cpp này (internal linkage)
static int demNoiBo = 0;

// extern: KHAI BÁO biến được ĐỊNH NGHĨA ở nơi khác (thường ở file .cpp khác).
// Ở đây định nghĩa ngay bên dưới để chương trình chạy được trong một file.
extern int soLanNhanNut;
int soLanNhanNut = 0;

int docCamBien() {
    static int lanGoi = 0;     // static CỤC BỘ: khởi tạo 1 lần, GIỮ giá trị giữa các lần gọi
    int tam = 0;               // biến tự động (automatic): tạo lại mỗi lần gọi
    lanGoi++;
    tam++;
    std::cout << "  docCamBien(): lanGoi = " << lanGoi << ", tam = " << tam << "\n";
    return lanGoi * 10;
}

class Led {
public:
    void bat() const {
        soLanTruyCap++;        // được phép sửa trong hàm const vì là mutable
        std::cout << "  LED bật (lần truy cập " << soLanTruyCap << ")\n";
    }
private:
    mutable int soLanTruyCap = 0;
};

// volatile: báo trình biên dịch "giá trị có thể bị thay đổi từ bên ngoài" (ngắt, phần cứng)
// -> không được tối ưu hoá bằng cách đọc từ thanh ghi CPU cũ, phải đọc lại bộ nhớ mỗi lần.
volatile bool coNgat = false;

void isrNutNhan() {            // giả lập hàm phục vụ ngắt (ISR)
    coNgat = true;
    soLanNhanNut++;
}

int main() {
    std::cout << "== static cục bộ ==\n";
    docCamBien();
    docCamBien();
    docCamBien();

    std::cout << "\n== static toàn cục & extern ==\n";
    demNoiBo += 5;
    isrNutNhan();
    isrNutNhan();
    std::cout << "  demNoiBo = " << demNoiBo << ", soLanNhanNut = " << soLanNhanNut << "\n";

    std::cout << "\n== mutable ==\n";
    const Led led;
    led.bat();
    led.bat();

    std::cout << "\n== volatile ==\n";
    if (coNgat) {
        coNgat = false;
        std::cout << "  Phát hiện ngắt từ nút nhấn -> xử lý trong loop()\n";
    }

    std::cout << "\n== thread_local ==\n";
    thread_local int moiLuongMotBan = 7;   // mỗi luồng có một bản riêng (xem bài Đa luồng)
    std::cout << "  moiLuongMotBan = " << moiLuongMotBan << "\n";
}

// Toán tử: số học, so sánh, logic, gán, bit (thao tác thanh ghi), ba ngôi
#include <bitset>
#include <cstdint>
#include <iostream>

void inBit(const char* ten, uint8_t v) {
    std::cout << "  " << ten << " = 0b" << std::bitset<8>(v) << " (" << +v << ")\n";
}

int main() {
    std::cout << "== Số học ==\n";
    int a = 17, b = 5;
    std::cout << "  17 + 5 = " << a + b << ", 17 - 5 = " << a - b << ", 17 * 5 = " << a * b << "\n";
    std::cout << "  17 / 5 = " << a / b << "   (chia SỐ NGUYÊN bỏ phần lẻ!)\n";
    std::cout << "  17 % 5 = " << a % b << "   (chia lấy dư)\n";
    std::cout << "  17.0 / 5 = " << 17.0 / b << "\n";
    int i = 5;
    int x = i++;      // dùng giá trị cũ rồi mới tăng
    int y = ++i;      // tăng trước rồi mới dùng
    std::cout << "  x = i++ -> " << x << ", y = ++i -> " << y << ", i = " << i << "\n";

    std::cout << "\n== So sánh & logic ==\n";
    float nhietDo = 31.5f;
    bool troiNong = nhietDo > 30;
    bool coNguoi = true;
    std::cout << std::boolalpha;
    std::cout << "  troiNong && coNguoi = " << (troiNong && coNguoi) << "\n";
    std::cout << "  troiNong || false   = " << (troiNong || false) << "\n";
    std::cout << "  !troiNong           = " << !troiNong << "\n";
    // Short-circuit: vế phải KHÔNG được tính nếu vế trái đã quyết định kết quả
    int* p = nullptr;
    if (p != nullptr && *p > 0) std::cout << "không bao giờ tới đây\n";
    std::cout << "  p != nullptr && *p > 0 -> an toàn nhờ short-circuit\n";

    std::cout << "\n== Toán tử gán kết hợp ==\n";
    int tong = 10;
    tong += 5; tong *= 2; tong -= 4; tong /= 2;
    std::cout << "  ((10 + 5) * 2 - 4) / 2 = " << tong << "\n";

    std::cout << "\n== Toán tử BIT – thao tác thanh ghi trong vi điều khiển ==\n";
    uint8_t PORTB = 0b00000000;            // giả lập thanh ghi 8 bit điều khiển 8 chân
    PORTB |= (1 << 5);                     // ĐẶT bit 5 = 1 (bật LED chân 13 Arduino Uno)
    inBit("Đặt bit 5   ", PORTB);
    PORTB |= (1 << 0) | (1 << 2);          // đặt nhiều bit cùng lúc
    inBit("Đặt bit 0,2 ", PORTB);
    PORTB &= ~(1 << 0);                    // XOÁ bit 0
    inBit("Xoá bit 0   ", PORTB);
    PORTB ^= (1 << 5);                     // ĐẢO bit 5 (nhấp nháy LED)
    inBit("Đảo bit 5   ", PORTB);
    bool bit2 = PORTB & (1 << 2);          // ĐỌC bit 2
    std::cout << "  Bit 2 đang = " << bit2 << "\n";
    uint16_t giaTri = 0xABCD;
    uint8_t byteCao = giaTri >> 8;         // lấy byte cao
    uint8_t byteThap = giaTri & 0xFF;      // lấy byte thấp
    std::cout << std::hex << std::uppercase;
    std::cout << "  0xABCD -> byte cao 0x" << +byteCao << ", byte thấp 0x" << +byteThap << "\n";
    std::cout << std::dec;
    std::cout << "  1 << 4 = " << (1 << 4) << " (nhân 2^4),  160 >> 3 = " << (160 >> 3) << " (chia 2^3)\n";

    std::cout << "\n== Ba ngôi & thứ tự ưu tiên ==\n";
    int pin = 87;
    std::cout << "  Pin " << pin << "%: " << (pin < 20 ? "SẮP HẾT" : "ổn") << "\n";
    std::cout << "  2 + 3 * 4 = " << 2 + 3 * 4 << ", (2 + 3) * 4 = " << (2 + 3) * 4 << "\n";
    uint8_t reg = 0b0100;
    // Bẫy: == ưu tiên cao hơn & -> phải có ngoặc
    std::cout << "  (reg & 4) == 4 -> " << ((reg & 4) == 4) << "\n";
}

// Câu lệnh rẽ nhánh: if, else if, else, switch
#include <iostream>

void xuLyNhietDo(float t) {
    std::cout << "  " << t << "°C -> ";
    if (t < 18) {
        std::cout << "lạnh: bật máy sưởi\n";
    } else if (t <= 28) {
        std::cout << "dễ chịu: tắt hết\n";
    } else if (t <= 35) {
        std::cout << "nóng: bật quạt\n";
    } else {
        std::cout << "quá nóng: bật quạt + còi cảnh báo\n";
    }
}

// Lệnh nhận qua Serial thường là 1 ký tự -> switch rất hợp
void xuLyLenh(char lenh) {
    std::cout << "  Lệnh '" << lenh << "': ";
    switch (lenh) {
        case 'F': std::cout << "robot đi thẳng\n";  break;
        case 'B': std::cout << "robot đi lùi\n";    break;
        case 'L':
        case 'l':                                   // nhiều case dùng chung một xử lý (fall-through)
            std::cout << "rẽ trái\n";               break;
        case 'S': std::cout << "dừng\n";            break;
        default:  std::cout << "không hiểu lệnh\n"; break;
    }
}

enum class CheDo { TuDong, ThuCong, TietKiem };

int main() {
    std::cout << "== if / else if / else ==\n";
    for (float t : {15.0f, 25.0f, 31.5f, 40.0f}) xuLyNhietDo(t);

    std::cout << "\n== switch ==\n";
    for (char c : {'F', 'l', 'S', 'X'}) xuLyLenh(c);

    std::cout << "\n== switch với enum class ==\n";
    CheDo cheDo = CheDo::TietKiem;
    switch (cheDo) {
        case CheDo::TuDong:   std::cout << "  Tự động\n"; break;
        case CheDo::ThuCong:  std::cout << "  Thủ công\n"; break;
        case CheDo::TietKiem: std::cout << "  Tiết kiệm pin: giảm độ sáng màn hình\n"; break;
    }

    std::cout << "\n== if có khởi tạo (C++17) ==\n";
    if (int adc = 3100; adc > 3000) {      // biến adc chỉ sống trong if/else này
        std::cout << "  ADC = " << adc << " > 3000: đất khô, bật bơm\n";
    }

    std::cout << "\n== Bẫy thường gặp ==\n";
    int x = 0;
    if (x = 5) {                           // GÁN chứ không phải SO SÁNH! luôn đúng (g++ -Wall sẽ cảnh báo)
        std::cout << "  if (x = 5) luôn chạy vào đây, x giờ = " << x << "\n";
    }
}

// Vòng lặp: for, while, do-while, range-for, break/continue – và vòng loop() "không chặn" kiểu Arduino
#include <iostream>

// Giả lập millis() của Arduino: mỗi lần gọi thời gian trôi thêm 100 ms
unsigned long thoiGian = 0;
unsigned long millis() { return thoiGian += 100; }

int main() {
    std::cout << "== for: đếm biết trước số lần ==\n  ";
    for (int i = 1; i <= 5; i++) std::cout << i << " ";
    std::cout << "\n";

    std::cout << "\n== while: lặp khi điều kiện còn đúng ==\n";
    int pin = 100;
    int phut = 0;
    while (pin > 20) {        // dùng tới khi pin xuống 20%
        pin -= 15;
        phut += 30;
    }
    std::cout << "  Sau " << phut << " phút pin còn " << pin << "%\n";

    std::cout << "\n== do-while: chạy ít nhất 1 lần ==\n";
    int lanThu = 0;
    bool ketNoi = false;
    do {
        lanThu++;
        ketNoi = (lanThu == 3);   // giả sử lần thứ 3 kết nối WiFi thành công
        std::cout << "  Thử kết nối WiFi lần " << lanThu << (ketNoi ? ": OK\n" : ": thất bại\n");
    } while (!ketNoi && lanThu < 5);

    std::cout << "\n== range-for: duyệt mọi phần tử ==\n  ";
    int docCamBien[] = {512, 530, 498, 1023, 505};
    long tong = 0;
    for (int v : docCamBien) tong += v;
    std::cout << "Trung bình = " << tong / 5 << "\n";

    std::cout << "\n== break & continue ==\n  ";
    for (int v : docCamBien) {
        if (v == 1023) { std::cout << "[nhiễu, bỏ qua] "; continue; }   // bỏ qua lượt này
        if (v < 500)   { std::cout << v << " [< 500, dừng] "; break; }   // thoát hẳn vòng lặp
        std::cout << v << " ";
    }
    std::cout << "\n";

    std::cout << "\n== Lồng nhau: vẽ ma trận LED 3x5 ==\n";
    for (int hang = 0; hang < 3; hang++) {
        std::cout << "  ";
        for (int cot = 0; cot < 5; cot++) std::cout << ((hang + cot) % 2 ? "○ " : "● ");
        std::cout << "\n";
    }

    std::cout << "\n== Vòng loop() không chặn (non-blocking) bằng millis() ==\n";
    // Thay vì delay(500) làm treo cả chương trình, ta kiểm tra "đã đủ thời gian chưa?"
    unsigned long lanCuoiNhay = 0;
    bool led = false;
    for (int vong = 0; vong < 25; vong++) {        // giả lập 25 lần chạy loop()
        unsigned long now = millis();
        if (now - lanCuoiNhay >= 500) {
            lanCuoiNhay = now;
            led = !led;
            std::cout << "  t=" << now << "ms: LED " << (led ? "BẬT" : "TẮT") << "\n";
        }
        // ... các việc khác (đọc nút, cảm biến) vẫn chạy mỗi vòng
    }
}

// Hàm: khai báo, định nghĩa, truyền tham trị / tham chiếu / con trỏ, mặc định, nạp chồng, đệ quy, inline
#include <iostream>

// 1. KHAI BÁO (prototype) trước – ĐỊNH NGHĨA ở cuối file. Thường đặt khai báo trong file .h
float celsiusToF(float c);

// 2. Truyền THAM TRỊ: hàm nhận BẢN SAO, sửa không ảnh hưởng biến gốc
void tangThamTri(int x) { x++; }

// 3. Truyền THAM CHIẾU: hàm làm việc trên CHÍNH biến gốc
void tangThamChieu(int& x) { x++; }

// 4. Truyền CON TRỎ: giống tham chiếu nhưng phải dùng * và có thể là nullptr
void tangConTro(int* x) { if (x) (*x)++; }

// 5. "Trả về nhiều giá trị" bằng tham chiếu đầu ra
void minMax(const int a[], int n, int& mn, int& mx) {
    mn = mx = a[0];
    for (int i = 1; i < n; i++) {
        if (a[i] < mn) mn = a[i];
        if (a[i] > mx) mx = a[i];
    }
}

// 6. Tham số MẶC ĐỊNH (phải nằm ở cuối danh sách)
void nhayLed(int pin, int soLan = 3, int msMoiLan = 200) {
    std::cout << "  Nháy LED chân " << pin << " x" << soLan << " lần, mỗi lần " << msMoiLan << "ms\n";
}

// 7. NẠP CHỒNG hàm: cùng tên, khác kiểu/số tham số
int binhPhuong(int x)       { return x * x; }
double binhPhuong(double x) { return x * x; }

// 8. ĐỆ QUY: hàm tự gọi chính nó – phải có điều kiện dừng
unsigned long giaiThua(unsigned n) { return n <= 1 ? 1 : n * giaiThua(n - 1); }

// 9. inline / constexpr: gợi ý chèn thân hàm tại chỗ gọi, tránh chi phí gọi hàm
constexpr int adcToMilliVolt(int adc) { return adc * 3300 / 4095; }

int main() {
    std::cout << "== Gọi hàm đã khai báo trước ==\n";
    std::cout << "  30°C = " << celsiusToF(30) << "°F\n";

    std::cout << "\n== Tham trị / tham chiếu / con trỏ ==\n";
    int a = 10;
    tangThamTri(a);    std::cout << "  sau tangThamTri:  a = " << a << "\n";
    tangThamChieu(a);  std::cout << "  sau tangThamChieu: a = " << a << "\n";
    tangConTro(&a);    std::cout << "  sau tangConTro:   a = " << a << "\n";

    int mau[] = {23, 7, 91, 45, 12};
    int mn, mx;
    minMax(mau, 5, mn, mx);
    std::cout << "  min = " << mn << ", max = " << mx << "\n";

    std::cout << "\n== Tham số mặc định ==\n";
    nhayLed(13);
    nhayLed(13, 5);
    nhayLed(2, 1, 1000);

    std::cout << "\n== Nạp chồng ==\n";
    std::cout << "  binhPhuong(7) = " << binhPhuong(7) << ", binhPhuong(1.5) = " << binhPhuong(1.5) << "\n";

    std::cout << "\n== Đệ quy ==\n";
    for (unsigned n : {0u, 5u, 10u}) std::cout << "  " << n << "! = " << giaiThua(n) << "\n";

    std::cout << "\n== constexpr: tính sẵn lúc biên dịch ==\n";
    constexpr int mv = adcToMilliVolt(2048);
    std::cout << "  ADC 2048 ≈ " << mv << " mV\n";

    std::cout << "\n== Lambda: hàm không tên, viết ngay tại chỗ ==\n";
    auto loc = [](int v) { return v > 50; };
    for (int v : mau) if (loc(v)) std::cout << "  " << v << " > 50\n";
}

// ĐỊNH NGHĨA hàm đã khai báo ở đầu file
float celsiusToF(float c) {
    return c * 9 / 5 + 32;
}

// Number: thư viện toán <cmath>, ép kiểu số, số ngẫu nhiên, các hàm tiện ích hay dùng trong Arduino
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <random>

// Tự viết lại map() và constrain() của Arduino
long mapRange(long x, long inMin, long inMax, long outMin, long outMax) {
    return (x - inMin) * (outMax - outMin) / (inMax - inMin) + outMin;
}

int main() {
    std::cout << std::fixed << std::setprecision(3);

    std::cout << "== <cmath> ==\n";
    std::cout << "  sqrt(2)      = " << std::sqrt(2.0) << "\n";
    std::cout << "  pow(2, 10)   = " << std::pow(2, 10) << "\n";
    std::cout << "  sin(30°)     = " << std::sin(30 * 3.14159265358979 / 180) << "\n";
    std::cout << "  hypot(3, 4)  = " << std::hypot(3, 4) << "   (khoảng cách)\n";
    std::cout << "  fabs(-2.5)   = " << std::fabs(-2.5) << ", abs(-7) = " << std::abs(-7) << "\n";
    std::cout << "  floor(2.7) = " << std::floor(2.7) << ", ceil(2.1) = " << std::ceil(2.1)
              << ", round(2.5) = " << std::round(2.5) << "\n";
    std::cout << "  log10(1000)  = " << std::log10(1000) << ", exp(1) = " << std::exp(1) << "\n";

    std::cout << "\n== Ép kiểu số ==\n";
    int adc = 2047;
    float volt1 = adc * 3.3 / 4095;               // 3.3 là double -> phép tính số thực
    float volt2 = adc * 33 / 40950;               // toàn số nguyên -> mất phần thập phân!
    float volt3 = static_cast<float>(adc) * 33 / 40950;
    std::cout << "  " << volt1 << " V (đúng) | " << volt2 << " V (sai: chia nguyên) | " << volt3 << " V (ép kiểu)\n";
    double d = 9.99;
    int cat = static_cast<int>(d);                // cắt phần lẻ, KHÔNG làm tròn
    int lamTron = static_cast<int>(std::lround(d));
    std::cout << "  (int)9.99 = " << cat << ", lround(9.99) = " << lamTron << "\n";

    std::cout << "\n== map() và constrain() kiểu Arduino ==\n";
    for (int bienTro : {0, 512, 1023}) {
        long pwm = mapRange(bienTro, 0, 1023, 0, 255);   // biến trở 10 bit -> PWM 8 bit
        std::cout << "  biến trở " << std::setw(4) << bienTro << " -> PWM " << pwm << "\n";
    }
    int tocDo = 300;
    std::cout << "  constrain(300, 0, 255) = " << std::clamp(tocDo, 0, 255) << "\n";

    std::cout << "\n== Số ngẫu nhiên ==\n";
    std::mt19937 gen(2026);                        // seed cố định -> lần nào chạy cũng giống nhau (dễ kiểm tra)
    std::uniform_int_distribution<int> xucXac(1, 6);
    std::cout << "  Tung xúc xắc: ";
    for (int i = 0; i < 8; i++) std::cout << xucXac(gen) << " ";
    std::cout << "\n  (Arduino: randomSeed(analogRead(A0)); random(1, 7);)\n";

    std::cout << "\n== Giới hạn & đặc biệt ==\n";
    std::cout << "  1.0 / 0 = " << 1.0 / 0 << ", sqrt(-1) = " << std::sqrt(-1.0)
              << ", isnan? " << std::boolalpha << std::isnan(std::sqrt(-1.0)) << "\n";
    float a = 0.1f + 0.2f;
    std::cout << "  So sánh số thực đúng cách: |a - 0.3| < 1e-6 ? " << (std::fabs(a - 0.3f) < 1e-6f) << "\n";
}

// Mảng: một chiều, hai chiều, truyền vào hàm, std::array, bộ đệm vòng (ring buffer)
#include <array>
#include <iostream>

// Mảng truyền vào hàm sẽ "suy biến" thành con trỏ -> phải truyền kèm số phần tử
int tinhTong(const int a[], int n) {
    int s = 0;
    for (int i = 0; i < n; i++) s += a[i];
    return s;
}

// std::array giữ được kích thước, có .size(), an toàn hơn
template <size_t N>
float trungBinh(const std::array<int, N>& a) {
    long s = 0;
    for (int v : a) s += v;
    return float(s) / a.size();
}

// Bộ lọc trung bình trượt dùng bộ đệm vòng – kỹ thuật kinh điển để lọc nhiễu cảm biến
class MovingAverage {
public:
    float them(int giaTri) {
        tong_ -= buf_[viTri_];
        buf_[viTri_] = giaTri;
        tong_ += giaTri;
        viTri_ = (viTri_ + 1) % N;     // quay vòng về 0 khi tới cuối mảng
        if (dem_ < N) dem_++;
        return float(tong_) / dem_;
    }
private:
    static constexpr int N = 4;
    int buf_[N] = {0};
    int viTri_ = 0, dem_ = 0;
    long tong_ = 0;
};

int main() {
    std::cout << "== Mảng một chiều ==\n";
    int nhietDo[7] = {28, 30, 31, 29, 27, 33, 32};   // nhiệt độ 7 ngày
    int n = sizeof(nhietDo) / sizeof(nhietDo[0]);     // số phần tử = tổng byte / byte mỗi phần tử
    std::cout << "  Số phần tử: " << n << ", phần tử đầu: " << nhietDo[0] << ", cuối: " << nhietDo[n - 1] << "\n";
    std::cout << "  Tổng: " << tinhTong(nhietDo, n) << "\n";
    int chanLed[] = {2, 4, 5, 18};                    // khởi tạo không ghi kích thước
    std::cout << "  Các chân LED: ";
    for (int p : chanLed) std::cout << p << " ";
    std::cout << "\n";
    int day[5] = {1, 2};                              // phần còn lại tự = 0
    std::cout << "  day[4] = " << day[4] << "\n";
    // nhietDo[7] = 0;  // LỖI NGUY HIỂM: truy cập ngoài mảng -> ghi đè bộ nhớ khác, không báo lỗi!

    std::cout << "\n== Mảng hai chiều: bản đồ 4x6 cho robot ==\n";
    const int H = 4, W = 6;
    char banDo[H][W] = {
        {'.', '.', '#', '.', '.', '.'},
        {'.', '#', '#', '.', '#', '.'},
        {'.', '.', '.', '.', '#', '.'},
        {'#', '#', '.', '.', '.', 'G'},
    };
    int soVatCan = 0;
    for (int r = 0; r < H; r++) {
        std::cout << "  ";
        for (int c = 0; c < W; c++) {
            std::cout << banDo[r][c] << ' ';
            if (banDo[r][c] == '#') soVatCan++;
        }
        std::cout << "\n";
    }
    std::cout << "  Số ô vật cản: " << soVatCan << "\n";

    std::cout << "\n== std::array ==\n";
    std::array<int, 5> adc = {510, 520, 505, 515, 500};
    std::cout << "  size = " << adc.size() << ", trung bình = " << trungBinh(adc) << "\n";
    std::cout << "  adc.at(2) = " << adc.at(2) << " (at() kiểm tra chỉ số, an toàn hơn [])\n";

    std::cout << "\n== Lọc nhiễu bằng trung bình trượt (ring buffer) ==\n";
    MovingAverage loc;
    for (int v : {500, 502, 498, 900, 501, 499, 503}) {   // 900 là nhiễu
        std::cout << "  đọc " << v << " -> sau lọc " << loc.them(v) << "\n";
    }
}

// Chuỗi: chuỗi kiểu C (char[]) và std::string – kèm ví dụ phân tích lệnh nhận từ Serial
#include <cstdio>
#include <cstring>
#include <iostream>
#include <string>

int main() {
    std::cout << "== Chuỗi kiểu C: mảng char kết thúc bằng '\\0' ==\n";
    char ten[16] = "ESP32";                 // 5 ký tự + '\0' = 6 byte được dùng
    std::cout << "  ten = " << ten << ", strlen = " << std::strlen(ten) << ", sizeof = " << sizeof(ten) << "\n";
    std::strcat(ten, "-S3");                // nối chuỗi (PHẢI đủ chỗ, nếu không sẽ tràn bộ đệm!)
    std::cout << "  sau strcat: " << ten << "\n";
    std::cout << "  strcmp(\"abc\", \"abd\") = " << std::strcmp("abc", "abd") << " (âm: abc đứng trước)\n";

    char buf[32];
    int nhiet = 28, am = 65;
    // snprintf: định dạng chuỗi AN TOÀN, không bao giờ ghi quá kích thước buf
    std::snprintf(buf, sizeof(buf), "T=%dC H=%d%%", nhiet, am);
    std::cout << "  snprintf -> \"" << buf << "\"\n";
    char nho[8];
    int canGhi = std::snprintf(nho, sizeof(nho), "Xin chao cac ban");
    std::cout << "  Bộ đệm 8 byte chỉ giữ: \"" << nho << "\" (cần " << canGhi << " ký tự)\n";

    std::cout << "\n== std::string: tự quản lý bộ nhớ, dễ dùng ==\n";
    std::string s = "Hello";
    s += ", BKSTAR";                        // nối
    std::cout << "  s = " << s << ", length = " << s.length() << "\n";
    std::cout << "  s.substr(7, 6) = " << s.substr(7, 6) << "\n";
    std::cout << "  s.find(\"BK\") = " << s.find("BK") << "\n";
    s.replace(0, 5, "Xin chao");
    std::cout << "  sau replace: " << s << "\n";
    std::cout << "  so sánh == : " << std::boolalpha << (std::string("on") == "on") << "\n";

    std::cout << "\n== Chuyển đổi số <-> chuỗi ==\n";
    std::string soChuoi = std::to_string(3.5);
    int so = std::stoi("123") + 1;
    float f = std::stof("27.75");
    std::cout << "  to_string(3.5) = " << soChuoi << ", stoi(\"123\")+1 = " << so << ", stof = " << f << "\n";

    std::cout << "\n== Phân tích lệnh dạng \"TEN:GIA_TRI\" nhận qua Serial ==\n";
    for (std::string lenh : {"LED:1", "SERVO:90", "SPEED:255", "SAI_CU_PHAP"}) {
        size_t pos = lenh.find(':');
        if (pos == std::string::npos) {
            std::cout << "  \"" << lenh << "\" -> lỗi cú pháp\n";
            continue;
        }
        std::string ten = lenh.substr(0, pos);
        int giaTri = std::stoi(lenh.substr(pos + 1));
        std::cout << "  \"" << lenh << "\" -> thiết bị " << ten << ", giá trị " << giaTri << "\n";
    }

    std::cout << "\n== Lưu ý tiếng Việt: length() đếm BYTE (UTF-8), không phải số chữ ==\n";
    std::string viet = "Việt";
    std::cout << "  \"Việt\" có 4 chữ nhưng length() = " << viet.length() << "\n";
}

// Con trỏ với địa chỉ – địa chỉ với con trỏ – con trỏ tới con trỏ
// (Địa chỉ thật thay đổi mỗi lần chạy nên ví dụ chỉ in KHOẢNG CÁCH và kết quả so sánh)
#include <cstdint>
#include <iostream>

void hoanDoi(int* a, int* b) {     // đổi chỗ hai biến qua con trỏ
    int tam = *a;
    *a = *b;
    *b = tam;
}

void capPhatLai(int** pp, int* moi) {   // con trỏ tới con trỏ: hàm SỬA ĐƯỢC chính con trỏ của bên gọi
    *pp = moi;
}

int main() {
    std::cout << std::boolalpha;
    std::cout << "== & lấy địa chỉ, * truy cập giá trị tại địa chỉ ==\n";
    int nhietDo = 28;
    int* p = &nhietDo;                   // p chứa ĐỊA CHỈ của nhietDo
    std::cout << "  *p = " << *p << "\n";
    *p = 35;                             // ghi qua con trỏ = ghi vào nhietDo
    std::cout << "  sau *p = 35: nhietDo = " << nhietDo << "\n";
    std::cout << "  p == &nhietDo ? " << (p == &nhietDo) << "\n";
    std::cout << "  sizeof(p) = " << sizeof(p) << " byte (máy 64 bit; ESP32/STM32 là 4 byte)\n";

    std::cout << "\n== nullptr: con trỏ không trỏ vào đâu ==\n";
    int* q = nullptr;
    if (q == nullptr) std::cout << "  q rỗng – luôn kiểm tra trước khi dùng *q\n";

    std::cout << "\n== Con trỏ và mảng: tên mảng là địa chỉ phần tử đầu ==\n";
    int adc[5] = {100, 200, 300, 400, 500};
    int* pa = adc;                       // tương đương &adc[0]
    std::cout << "  *pa = " << *pa << ", *(pa + 2) = " << *(pa + 2) << ", pa[3] = " << pa[3] << "\n";
    std::cout << "  (pa + 1) cách pa bao nhiêu byte? "
              << (reinterpret_cast<uintptr_t>(pa + 1) - reinterpret_cast<uintptr_t>(pa))
              << " = sizeof(int)\n";
    std::cout << "  Duyệt bằng con trỏ: ";
    for (int* it = adc; it != adc + 5; ++it) std::cout << *it << " ";
    std::cout << "\n  Số phần tử giữa hai con trỏ: " << (&adc[4] - &adc[0]) << "\n";

    std::cout << "\n== Truyền con trỏ vào hàm ==\n";
    int a = 1, b = 2;
    hoanDoi(&a, &b);
    std::cout << "  sau hoanDoi: a = " << a << ", b = " << b << "\n";

    std::cout << "\n== Con trỏ tới con trỏ (int**) ==\n";
    int x = 10, y = 20;
    int* px = &x;
    int** ppx = &px;                     // ppx trỏ tới biến con trỏ px
    std::cout << "  **ppx = " << **ppx << "\n";
    capPhatLai(&px, &y);                 // hàm đổi px sang trỏ y
    std::cout << "  sau capPhatLai: *px = " << *px << ", px == &y ? " << (px == &y) << "\n";

    std::cout << "\n== Mảng con trỏ: bảng tên chế độ ==\n";
    const char* cheDo[] = {"TẮT", "TỰ ĐỘNG", "THỦ CÔNG"};
    for (int i = 0; i < 3; i++) std::cout << "  cheDo[" << i << "] = " << cheDo[i] << "\n";

    std::cout << "\n== const với con trỏ ==\n";
    const int* chiDoc = &x;   // không sửa được GIÁ TRỊ qua con trỏ:  *chiDoc = 5 -> lỗi
    int* const coDinh = &x;   // không đổi được ĐỊA CHỈ:               coDinh = &y -> lỗi
    *coDinh = 11;
    std::cout << "  *chiDoc = " << *chiDoc << "\n";
}

// Ép kiểu con trỏ: xem một số nguyên như dãy byte, int <-> char, endian, đóng gói gói tin, thanh ghi
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <iostream>

void inByte(const char* ten, const void* p, size_t n) {
    const uint8_t* b = static_cast<const uint8_t*>(p);   // void* -> uint8_t* để đọc từng byte
    std::printf("  %-12s:", ten);
    for (size_t i = 0; i < n; i++) std::printf(" %02X", b[i]);
    std::printf("\n");
}

// Mô phỏng một khối thanh ghi ngoại vi (thực tế nằm ở địa chỉ cố định, vd 0x40020000 trên STM32)
struct GPIO_TypeDef {
    volatile uint32_t MODER;
    volatile uint32_t ODR;
};
uint32_t vungNhoGiaLap[2] = {0, 0};

int main() {
    std::cout << "== int <-> char ==\n";
    char c = 'B';
    int maAscii = c;                                    // char -> int: lấy mã
    char chuSo = '0' + 7;                               // int -> ký tự chữ số
    int giaTri = '9' - '0';                             // ký tự chữ số -> int
    std::cout << "  'B' = " << maAscii << ", '0'+7 = '" << chuSo << "', '9'-'0' = " << giaTri << "\n";
    int lon = 300;
    char cat = static_cast<char>(lon);                  // chỉ giữ 8 bit thấp: 300 = 0x12C -> 0x2C
    std::cout << "  (char)300 = " << int(static_cast<unsigned char>(cat)) << " (mất dữ liệu!)\n";

    std::cout << "\n== Xem số nguyên 32 bit như 4 byte (ép uint32_t* -> uint8_t*) ==\n";
    uint32_t so = 0x12345678;
    uint8_t* pb = reinterpret_cast<uint8_t*>(&so);
    std::printf("  pb[0..3] = %02X %02X %02X %02X\n", pb[0], pb[1], pb[2], pb[3]);
    std::cout << "  -> " << (pb[0] == 0x78 ? "LITTLE endian (x86, ARM, ESP32: byte thấp nằm trước)" : "BIG endian") << "\n";

    std::cout << "\n== Đóng gói dữ liệu cảm biến thành mảng byte để gửi UART/LoRa ==\n";
    #pragma pack(push, 1)                               // bỏ byte đệm giữa các trường
    struct GoiTin {
        uint8_t  id;
        int16_t  nhietDoX10;                            // 28.5°C gửi dưới dạng 285
        uint16_t doAm;
        float    apSuat;
    };
    #pragma pack(pop)
    GoiTin g{0x01, 285, 65, 1013.25f};
    inByte("GoiTin", &g, sizeof(g));
    std::cout << "  sizeof(GoiTin) = " << sizeof(g) << " byte (không pack sẽ là 12)\n";
    // Phía nhận: chép mảng byte trở lại struct bằng memcpy (an toàn hơn ép con trỏ)
    uint8_t nhan[sizeof(GoiTin)];
    std::memcpy(nhan, &g, sizeof(g));
    GoiTin g2;
    std::memcpy(&g2, nhan, sizeof(g2));
    std::cout << "  Phía nhận: id=" << +g2.id << ", T=" << g2.nhietDoX10 / 10.0 << "°C, H=" << g2.doAm
              << "%, P=" << g2.apSuat << " hPa\n";

    std::cout << "\n== Lấy bit pattern của float ==\n";
    float f = 1.0f;
    uint32_t bits;
    std::memcpy(&bits, &f, sizeof(bits));               // cách đúng chuẩn (tránh vi phạm strict aliasing)
    std::printf("  1.0f = 0x%08X (dấu | mũ | phần định trị theo IEEE-754)\n", bits);

    std::cout << "\n== Ép địa chỉ thành con trỏ tới thanh ghi (cách viết driver) ==\n";
    // Trên STM32: #define GPIOA ((GPIO_TypeDef*)0x40020000)
    GPIO_TypeDef* GPIOA = reinterpret_cast<GPIO_TypeDef*>(vungNhoGiaLap);
    GPIOA->MODER |= (1u << (5 * 2));                    // chân 5 = output
    GPIOA->ODR   |= (1u << 5);                          // xuất mức 1 ra chân 5
    std::printf("  MODER = 0x%08X, ODR = 0x%08X\n", (unsigned)GPIOA->MODER, (unsigned)GPIOA->ODR);

    std::cout << "\n== Các toán tử ép kiểu của C++ ==\n";
    std::cout << "  static_cast       : chuyển đổi hợp lệ (số <-> số, void* -> T*)\n";
    std::cout << "  reinterpret_cast  : diễn giải lại bit/địa chỉ (thanh ghi, byte) – nguy hiểm\n";
    std::cout << "  const_cast        : bỏ const – hầu như không nên dùng\n";
    std::cout << "  dynamic_cast      : ép xuống lớp con có kiểm tra (cần RTTI)\n";
}

// Con trỏ hàm: callback, bảng xử lý lệnh, so sánh với std::function và lambda
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>

int cong(int a, int b) { return a + b; }
int nhan(int a, int b) { return a * b; }

// Hàm nhận một hàm khác làm tham số (callback)
int apDung(int (*phepToan)(int, int), int a, int b) { return phepToan(a, b); }

// Kiểu con trỏ hàm có tên cho dễ đọc
using HamXuLy = void (*)(int);

void batLed(int v)    { std::cout << "  -> LED " << (v ? "bật" : "tắt") << "\n"; }
void quayServo(int v) { std::cout << "  -> Servo quay " << v << " độ\n"; }
void datToc(int v)    { std::cout << "  -> Động cơ tốc độ " << v << "\n"; }

// Bảng tra lệnh: tên -> hàm xử lý. Thêm lệnh mới chỉ cần thêm một dòng.
struct MucLenh { const char* ten; HamXuLy ham; };
const MucLenh BANG_LENH[] = {
    {"LED",   batLed},
    {"SERVO", quayServo},
    {"SPEED", datToc},
};

void thucThi(const char* ten, int giaTri) {
    for (const MucLenh& m : BANG_LENH) {
        if (std::strcmp(m.ten, ten) == 0) { m.ham(giaTri); return; }
    }
    std::cout << "  -> Không có lệnh " << ten << "\n";
}

// Giả lập attachInterrupt(pin, callback): đăng ký hàm sẽ được gọi khi có sự kiện
void (*callbackNut)() = nullptr;
void attachInterrupt(void (*cb)()) { callbackNut = cb; }
void khiNhanNut() { std::cout << "  [ISR] Nút được nhấn!\n"; }

int soSanhTang(const void* a, const void* b) {
    return *static_cast<const int*>(a) - *static_cast<const int*>(b);
}

int main() {
    std::cout << "== Con trỏ hàm cơ bản ==\n";
    int (*f)(int, int) = cong;
    std::cout << "  f = cong: f(3, 4) = " << f(3, 4) << "\n";
    f = nhan;
    std::cout << "  f = nhan: f(3, 4) = " << f(3, 4) << "\n";
    std::cout << "  apDung(cong, 10, 5) = " << apDung(cong, 10, 5) << "\n";

    std::cout << "\n== Bảng xử lý lệnh ==\n";
    thucThi("LED", 1);
    thucThi("SERVO", 90);
    thucThi("BUZZER", 1);

    std::cout << "\n== Callback kiểu attachInterrupt ==\n";
    attachInterrupt(khiNhanNut);
    if (callbackNut) callbackNut();          // phần cứng "gọi lại" khi có ngắt

    std::cout << "\n== qsort của C nhận con trỏ hàm so sánh ==\n  ";
    int a[] = {42, 7, 19, 3, 25};
    std::qsort(a, 5, sizeof(int), soSanhTang);
    for (int v : a) std::cout << v << " ";
    std::cout << "\n";

    std::cout << "\n== std::function + lambda: linh hoạt hơn (có thể mang theo biến) ==\n";
    int nguong = 30;
    std::function<bool(int)> kiemTra = [nguong](int t) { return t > nguong; };   // lambda "bắt" biến nguong
    for (int t : {25, 35}) std::cout << "  " << t << "°C vượt ngưỡng? " << std::boolalpha << kiemTra(t) << "\n";
    std::cout << "  sizeof(con trỏ hàm) = " << sizeof(f) << ", sizeof(std::function) = " << sizeof(kiemTra)
              << " -> trên MCU ưu tiên con trỏ hàm\n";
}

// Tham chiếu (reference): bí danh của một biến – so sánh với con trỏ
#include <iostream>
#include <string>
#include <vector>

struct CamBien { std::string ten; float giaTri; };

void hieuChinh(CamBien& cb, float lech) { cb.giaTri += lech; }     // sửa trực tiếp

// const & : đọc nhanh (không sao chép) nhưng không sửa được – cách truyền object lớn chuẩn nhất
void inCamBien(const CamBien& cb) {
    std::cout << "  " << cb.ten << " = " << cb.giaTri << "\n";
    // cb.giaTri = 0;   // LỖI: cb là const
}

// Trả về tham chiếu -> có thể gán vào kết quả của hàm
int& phanTu(std::vector<int>& v, size_t i) { return v[i]; }

int main() {
    std::cout << "== Tham chiếu là tên khác của cùng một biến ==\n";
    int tocDo = 100;
    int& rTocDo = tocDo;            // PHẢI khởi tạo ngay, và không thể đổi sang biến khác
    rTocDo = 150;
    std::cout << "  tocDo = " << tocDo << ", &rTocDo == &tocDo ? " << std::boolalpha << (&rTocDo == &tocDo) << "\n";

    std::cout << "\n== Truyền tham chiếu vào hàm ==\n";
    CamBien dht{"DHT22", 27.0f};
    hieuChinh(dht, -0.5f);
    inCamBien(dht);

    std::cout << "\n== Trả về tham chiếu ==\n";
    std::vector<int> ds = {1, 2, 3};
    phanTu(ds, 1) = 99;
    std::cout << "  ds[1] = " << ds[1] << "\n";

    std::cout << "\n== range-for: có & thì sửa được, không có & thì chỉ sửa bản sao ==\n";
    std::vector<CamBien> cacCamBien = {{"A0", 1.0f}, {"A1", 2.0f}};
    for (CamBien c : cacCamBien) c.giaTri *= 10;           // bản sao -> không đổi
    std::cout << "  không &: A0 = " << cacCamBien[0].giaTri << "\n";
    for (CamBien& c : cacCamBien) c.giaTri *= 10;          // tham chiếu -> đổi thật
    std::cout << "  có &   : A0 = " << cacCamBien[0].giaTri << "\n";
    for (const auto& c : cacCamBien) inCamBien(c);         // chỉ đọc: const auto&

    std::cout << "\n== Con trỏ vs tham chiếu ==\n";
    std::cout << "  Con trỏ: có thể nullptr, đổi được nơi trỏ tới, dùng *p / p->\n";
    std::cout << "  Tham chiếu: luôn gắn với một biến, không đổi được, dùng như biến thường\n";
}

// Struct (cấu trúc dữ liệu) và Input/Output cơ bản: cin, cout, định dạng
// Dữ liệu nhập được đưa vào từ bàn phím (ở đây đã chuẩn bị sẵn – xem ô "Dữ liệu nhập")
#include <iomanip>
#include <iostream>
#include <string>

struct DiemDo {                 // gom các dữ liệu liên quan thành một kiểu mới
    std::string viTri;
    float nhietDo;
    int doAm;
};

struct KhongToiUu { char a; int b; char c; };   // trình biên dịch chèn byte đệm (padding)
struct ToiUu      { int b; char a; char c; };   // sắp trường lớn trước -> nhỏ hơn

void inDiemDo(const DiemDo& d) {
    std::cout << "  | " << std::left << std::setw(10) << d.viTri
              << " | " << std::right << std::setw(6) << std::fixed << std::setprecision(1) << d.nhietDo
              << " | " << std::setw(4) << d.doAm << " |\n";
}

int main() {
    std::cout << "== Nhập dữ liệu bằng cin ==\n";
    int soDiem;
    std::cout << "Nhập số điểm đo: ";
    std::cin >> soDiem;
    std::cout << soDiem << "\n";

    DiemDo ds[10];
    for (int i = 0; i < soDiem && i < 10; i++) {
        std::cout << "Điểm " << i + 1 << " (vị trí nhiệt-độ độ-ẩm): ";
        std::cin >> ds[i].viTri >> ds[i].nhietDo >> ds[i].doAm;
        std::cout << ds[i].viTri << " " << ds[i].nhietDo << " " << ds[i].doAm << "\n";
    }

    std::cout << "\n== In bảng có định dạng (iomanip) ==\n";
    std::cout << "  +------------+--------+------+\n";
    std::cout << "  | Vị trí     |   T°C  |  H%  |\n";
    std::cout << "  +------------+--------+------+\n";
    float tong = 0;
    for (int i = 0; i < soDiem; i++) { inDiemDo(ds[i]); tong += ds[i].nhietDo; }
    std::cout << "  +------------+--------+------+\n";
    std::cout << "  Nhiệt độ trung bình: " << tong / soDiem << "°C\n";

    std::cout << "\n== Struct lồng nhau, khởi tạo nhanh, gán cả struct ==\n";
    struct ThietBi { int id; DiemDo docGanNhat; };
    ThietBi tb = {7, {"Vuon", 30.5f, 70}};
    ThietBi banSao = tb;                      // sao chép toàn bộ các trường
    banSao.docGanNhat.nhietDo = 0;
    std::cout << "  tb.docGanNhat.nhietDo = " << tb.docGanNhat.nhietDo << " (bản sao độc lập)\n";

    std::cout << "\n== Kích thước struct và padding ==\n";
    std::cout << "  sizeof(KhongToiUu) = " << sizeof(KhongToiUu) << ", sizeof(ToiUu) = " << sizeof(ToiUu) << "\n";

    std::cout << "\n== Các cách in số ==\n";
    int v = 255;
    std::cout << "  dec " << std::dec << v << " | hex 0x" << std::hex << std::uppercase << v
              << " | oct " << std::oct << v << std::dec << "\n";
    std::cout << "  setfill: [" << std::setfill('0') << std::setw(5) << 42 << "]" << std::setfill(' ') << "\n";
    std::cerr << "(cerr: luồng báo lỗi riêng, không bị đệm)\n";
}

// Ngày & giờ: <ctime> kiểu C và <chrono> kiểu C++
#include <chrono>
#include <ctime>
#include <iostream>
#include <thread>

int main() {
    std::cout << "== time_t: số giây kể từ 1/1/1970 (Unix time) ==\n";
    // Dùng một mốc cố định để ví dụ lần nào chạy cũng ra cùng kết quả.
    // Thực tế: std::time(nullptr) lấy giờ hiện tại; ESP32 đồng bộ giờ qua NTP rồi dùng y hệt.
    std::time_t t = 1760000000;
    std::tm utc = *std::gmtime(&t);
    char buf[64];
    std::strftime(buf, sizeof(buf), "%d/%m/%Y %H:%M:%S", &utc);
    std::cout << "  t = " << t << " -> " << buf << " (UTC)\n";
    std::cout << "  Thứ trong tuần (0 = CN): " << utc.tm_wday << ", ngày thứ " << utc.tm_yday + 1 << " trong năm\n";

    std::time_t gioVN = t + 7 * 3600;         // múi giờ Việt Nam UTC+7
    std::tm vn = *std::gmtime(&gioVN);
    std::strftime(buf, sizeof(buf), "%H:%M ngày %d/%m", &vn);
    std::cout << "  Giờ Việt Nam: " << buf << "\n";

    std::cout << "\n== Tính khoảng cách giữa hai ngày ==\n";
    std::tm ngayThi{};
    ngayThi.tm_year = 2026 - 1900; ngayThi.tm_mon = 11 - 1; ngayThi.tm_mday = 15;   // 15/11/2026
    std::tm homNay{};
    homNay.tm_year = 2026 - 1900; homNay.tm_mon = 10 - 1; homNay.tm_mday = 9;       // 09/10/2026
    double giay = std::difftime(std::mktime(&ngayThi), std::mktime(&homNay));
    std::cout << "  Từ 09/10 tới ngày thi 15/11 còn " << giay / 86400 << " ngày\n";

    std::cout << "\n== <chrono>: đơn vị thời gian an toàn kiểu ==\n";
    using namespace std::chrono;
    auto chuKy = milliseconds(1500);
    std::cout << "  1500 ms = " << duration_cast<seconds>(chuKy).count() << " s (cắt) = "
              << duration<double>(chuKy).count() << " s\n";
    auto tong = minutes(2) + seconds(30);
    std::cout << "  2 phút + 30 giây = " << tong.count() << " giây\n";

    std::cout << "\n== Đo thời gian thực thi (giống micros() trên Arduino) ==\n";
    auto batDau = steady_clock::now();
    std::this_thread::sleep_for(milliseconds(50));
    auto daQua = duration_cast<milliseconds>(steady_clock::now() - batDau).count();
    std::cout << "  sleep_for(50ms) mất khoảng " << (daQua >= 50 ? ">= 50" : "< 50") << " ms\n";
}

// Lớp & đối tượng, tính bao đóng (encapsulation): private/public, constructor, destructor, getter/setter
#include <iostream>
#include <string>

class Led {
public:
    // Constructor: chạy khi đối tượng được tạo. Dùng danh sách khởi tạo ": pin_(pin), ..."
    Led(int pin, std::string ten = "LED") : pin_(pin), ten_(std::move(ten)) {
        soLuong++;
        std::cout << "  [tạo] " << ten_ << " ở chân " << pin_ << "\n";
    }
    // Destructor: chạy khi đối tượng bị huỷ (ra khỏi phạm vi)
    ~Led() {
        soLuong--;
        std::cout << "  [huỷ] " << ten_ << "\n";
    }

    void bat()  { trangThai_ = true;  doSang_ = 255; }
    void tat()  { trangThai_ = false; doSang_ = 0; }

    // Setter có KIỂM TRA dữ liệu – lý do chính của bao đóng
    bool datDoSang(int giaTri) {
        if (giaTri < 0 || giaTri > 255) return false;   // từ chối giá trị sai
        doSang_ = giaTri;
        trangThai_ = giaTri > 0;
        return true;
    }

    // Getter là hàm const: hứa không sửa đối tượng
    int doSang() const { return doSang_; }
    bool dangBat() const { return trangThai_; }
    void inTrangThai() const {
        std::cout << "  " << ten_ << "(chân " << pin_ << "): " << (trangThai_ ? "BẬT" : "TẮT")
                  << ", độ sáng " << doSang_ << "\n";
    }

    static int soLuong;              // thành viên static: dùng chung cho MỌI đối tượng của lớp

private:                             // bên ngoài không truy cập trực tiếp được
    const int pin_;                  // const: chân cố định suốt đời đối tượng
    std::string ten_;
    bool trangThai_ = false;         // giá trị mặc định
    int doSang_ = 0;
};
int Led::soLuong = 0;                // định nghĩa thành viên static

int main() {
    std::cout << "== Tạo đối tượng ==\n";
    Led ledDo(13, "LED đỏ");
    Led ledXanh(12, "LED xanh");
    std::cout << "  Số LED đang tồn tại: " << Led::soLuong << "\n";

    std::cout << "\n== Gọi phương thức ==\n";
    ledDo.bat();
    ledXanh.datDoSang(80);
    ledDo.inTrangThai();
    ledXanh.inTrangThai();

    std::cout << "\n== Bao đóng bảo vệ dữ liệu ==\n";
    // ledXanh.doSang_ = 999;        // LỖI biên dịch: doSang_ là private
    bool ok = ledXanh.datDoSang(999);
    std::cout << "  datDoSang(999) -> " << (ok ? "chấp nhận" : "từ chối") << ", độ sáng vẫn = " << ledXanh.doSang() << "\n";

    std::cout << "\n== Vòng đời: đối tượng trong khối {} bị huỷ khi ra khỏi khối ==\n";
    {
        Led tam(2, "LED tạm");
        std::cout << "  Số LED: " << Led::soLuong << "\n";
    }
    std::cout << "  Số LED sau khối: " << Led::soLuong << "\n";

    std::cout << "\n== Kết thúc main: các đối tượng còn lại bị huỷ theo thứ tự NGƯỢC lúc tạo ==\n";
}

// RAII (Resource Acquisition Is Initialization) và quy tắc sao chép (copy constructor, operator=)
#include <cstring>
#include <iostream>

// Ví dụ RAII: "khoá bus I2C" – lấy khi tạo, TỰ trả khi huỷ, kể cả khi return sớm
class I2CLock {
public:
    I2CLock()  { std::cout << "    [lock]   chiếm bus I2C\n"; }
    ~I2CLock() { std::cout << "    [unlock] trả bus I2C\n"; }
};

bool docCamBien(int diaChi) {
    I2CLock khoa;                          // chiếm bus
    std::cout << "    đọc thiết bị 0x" << std::hex << diaChi << std::dec << "\n";
    if (diaChi == 0x77) {
        std::cout << "    thiết bị không phản hồi -> return sớm\n";
        return false;                      // bus VẪN được trả nhờ destructor
    }
    return true;
}

// Lớp tự quản lý bộ nhớ -> cần viết copy constructor & operator= (quy tắc 3)
class BoDem {
public:
    explicit BoDem(size_t n) : n_(n), data_(new int[n]{}) {}
    ~BoDem() { delete[] data_; }

    BoDem(const BoDem& khac) : n_(khac.n_), data_(new int[khac.n_]) {      // sao chép SÂU
        std::memcpy(data_, khac.data_, n_ * sizeof(int));
        std::cout << "  [copy constructor]\n";
    }
    BoDem& operator=(const BoDem& khac) {
        if (this != &khac) {                                                // tự gán cho chính mình
            int* moi = new int[khac.n_];
            std::memcpy(moi, khac.data_, khac.n_ * sizeof(int));
            delete[] data_;
            data_ = moi;
            n_ = khac.n_;
        }
        std::cout << "  [operator=]\n";
        return *this;
    }

    int& operator[](size_t i) { return data_[i]; }
private:
    size_t n_;
    int* data_;
};

// Lớp quản lý phần cứng duy nhất thì nên CẤM sao chép
class UartPort {
public:
    UartPort() = default;
    UartPort(const UartPort&) = delete;
    UartPort& operator=(const UartPort&) = delete;
};

int main() {
    std::cout << "== RAII ==\n";
    bool kq1 = docCamBien(0x76);
    std::cout << "  -> kết quả " << std::boolalpha << kq1 << "\n";
    bool kq2 = docCamBien(0x77);
    std::cout << "  -> kết quả " << kq2 << "\n";

    std::cout << "\n== Sao chép sâu ==\n";
    BoDem a(3);
    a[0] = 10;
    BoDem b = a;            // copy constructor
    b[0] = 99;
    std::cout << "  a[0] = " << a[0] << ", b[0] = " << b[0] << " -> hai bộ đệm độc lập\n";
    BoDem c(1);
    c = a;                  // operator=
    std::cout << "  c[0] = " << c[0] << "\n";

    std::cout << "\n== Cấm sao chép ==\n";
    [[maybe_unused]] UartPort uart0;
    // UartPort uart1 = uart0;   // LỖI biên dịch: copy constructor đã bị delete
    std::cout << "  UartPort không thể sao chép -> tránh 2 đối tượng cùng điều khiển một cổng\n";
}

// Tính kế thừa: lớp cha / lớp con, protected, thứ tự constructor-destructor, gọi hàm lớp cha
#include <iostream>
#include <string>

class CamBien {                                   // lớp CHA (base class)
public:
    CamBien(std::string ten, int chan, int giaLap) : ten_(std::move(ten)), chan_(chan), giaLap_(giaLap) {
        std::cout << "  CamBien() " << ten_ << "\n";
    }
    ~CamBien() { std::cout << "  ~CamBien() " << ten_ << "\n"; }

    void moTa() const { std::cout << "  " << ten_ << " nối chân " << chan_ << "\n"; }
    int docThoTho() const { return giaLap_; }     // giả lập analogRead (ADC 10 bit, 0..1023)

protected:                                        // lớp con dùng được, bên ngoài thì không
    std::string ten_;
    int chan_;
private:
    int giaLap_;
};

class CamBienNhiet : public CamBien {             // lớp CON kế thừa public
public:
    CamBienNhiet(int chan) : CamBien("LM35", chan, 88) {   // gọi constructor lớp cha trước
        std::cout << "  CamBienNhiet()\n";
    }
    ~CamBienNhiet() { std::cout << "  ~CamBienNhiet()\n"; }

    float docC() const {                          // thêm chức năng mới
        return docThoTho() * 3.3f / 1023 * 100;   // dùng lại hàm của lớp cha
    }
    void moTa() const {                           // che (hide) hàm cùng tên của lớp cha
        CamBien::moTa();                          // vẫn gọi được bản của lớp cha
        std::cout << "  -> loại cảm biến nhiệt, 10 mV/°C, ten_ (protected) = " << ten_ << "\n";
    }
};

class CamBienAnhSang : public CamBien {
public:
    CamBienAnhSang(int chan) : CamBien("LDR", chan, 512) {}
    bool troiToi() const { return docThoTho() < 600; }
};

// Đa kế thừa: một lớp có nhiều lớp cha (dùng thận trọng)
class CoTheGuiWifi { public: void gui(const std::string& s) const { std::cout << "  WiFi gửi: " << s << "\n"; } };
class TramThoiTiet : public CamBienNhiet, public CoTheGuiWifi {
public:
    TramThoiTiet() : CamBienNhiet(34) {}
    void baoCao() const { gui("T=" + std::to_string(int(docC())) + "C"); }
};

int main() {
    std::cout << "== Tạo đối tượng lớp con: constructor CHA chạy trước ==\n";
    {
        CamBienNhiet lm35(36);
        lm35.moTa();
        std::cout << "  Nhiệt độ: " << lm35.docC() << "°C\n";
        // lm35.ten_ = "x";     // LỖI: protected không truy cập được từ bên ngoài
        std::cout << "== Ra khỏi khối: destructor CON chạy trước ==\n";
    }

    std::cout << "\n== Lớp con khác cùng lớp cha ==\n";
    CamBienAnhSang ldr(39);
    ldr.moTa();
    std::cout << "  Trời tối? " << std::boolalpha << ldr.troiToi() << "\n";

    std::cout << "\n== Đa kế thừa ==\n";
    TramThoiTiet tram;
    tram.baoCao();
    std::cout << "\n== Hết main ==\n";
}

// Nạp chồng (overloading): nạp chồng hàm, constructor và toán tử
#include <cmath>
#include <iostream>
#include <string>

// ===== Nạp chồng hàm: cùng tên, khác tham số =====
void guiSerial(int v)                { std::cout << "  gửi số nguyên: " << v << "\n"; }
void guiSerial(float v)              { std::cout << "  gửi số thực: " << v << "\n"; }
void guiSerial(const std::string& s) { std::cout << "  gửi chuỗi: \"" << s << "\"\n"; }
void guiSerial(int v, int coSo)      { std::cout << "  gửi " << v << " theo cơ số " << coSo << "\n"; }

// ===== Nạp chồng toán tử: lớp Vector2 cho vị trí robot =====
class Vector2 {
public:
    Vector2(float x = 0, float y = 0) : x(x), y(y) {}           // nạp chồng constructor qua tham số mặc định

    Vector2 operator+(const Vector2& o) const { return {x + o.x, y + o.y}; }
    Vector2 operator-(const Vector2& o) const { return {x - o.x, y - o.y}; }
    Vector2 operator*(float k) const          { return {x * k, y * k}; }
    Vector2& operator+=(const Vector2& o)     { x += o.x; y += o.y; return *this; }
    bool operator==(const Vector2& o) const   { return x == o.x && y == o.y; }
    float doDai() const { return std::sqrt(x * x + y * y); }

    // operator<< để in trực tiếp bằng cout – là hàm friend (không phải thành viên)
    friend std::ostream& operator<<(std::ostream& os, const Vector2& v) {
        return os << "(" << v.x << ", " << v.y << ")";
    }

    float x, y;
};

// ===== operator[] và operator() =====
class BangLed {
public:
    bool& operator[](int i) { return led_[i]; }               // truy cập như mảng
    void operator()() const {                                   // gọi đối tượng như một hàm
        std::cout << "  ";
        for (bool b : led_) std::cout << (b ? "●" : "○");
        std::cout << "\n";
    }
private:
    bool led_[8] = {};
};

int main() {
    std::cout << "== Nạp chồng hàm ==\n";
    guiSerial(42);
    guiSerial(3.14f);
    guiSerial(std::string("OK"));
    guiSerial(255, 16);

    std::cout << "\n== Nạp chồng toán tử ==\n";
    Vector2 viTri(1, 2);
    Vector2 vanToc(0.5f, 0);
    for (int buoc = 0; buoc < 3; buoc++) viTri += vanToc;
    std::cout << "  vị trí sau 3 bước: " << viTri << "\n";
    Vector2 dich(4, 6);
    Vector2 conLai = dich - viTri;
    std::cout << "  còn cách đích: " << conLai << ", khoảng cách = " << conLai.doDai() << "\n";
    std::cout << "  vanToc * 4 = " << vanToc * 4 << ", viTri == (2.5, 2)? " << std::boolalpha
              << (viTri == Vector2(2.5f, 2)) << "\n";

    std::cout << "\n== operator[] và operator() ==\n";
    BangLed bang;
    bang[0] = bang[3] = bang[7] = true;
    bang();
}

// Tính đa hình (polymorphism): hàm ảo (virtual), override, liên kết động, destructor ảo
#include <iostream>
#include <memory>

class DongCo {
public:
    virtual ~DongCo() { std::cout << "    ~DongCo()\n"; }     // destructor ẢO – bắt buộc với lớp cha đa hình
    virtual void chay(int tocDo) { std::cout << "  DongCo chung chạy " << tocDo << "\n"; }
    void tenLop() { std::cout << "  (hàm KHÔNG ảo của DongCo)\n"; }
};

class DongCoDC : public DongCo {
public:
    ~DongCoDC() override { std::cout << "    ~DongCoDC() – tắt PWM\n"; }
    void chay(int tocDo) override { std::cout << "  Động cơ DC: PWM duty = " << tocDo * 100 / 255 << "%\n"; }
    void tenLop() { std::cout << "  (hàm KHÔNG ảo của DongCoDC)\n"; }
};

class DongCoBuoc : public DongCo {
public:
    ~DongCoBuoc() override { std::cout << "    ~DongCoBuoc() – nhả cuộn dây\n"; }
    void chay(int tocDo) override { std::cout << "  Động cơ bước: " << tocDo * 10 << " bước/giây\n"; }
};

class Servo : public DongCo {
public:
    void chay(int goc) override { std::cout << "  Servo quay tới " << goc * 180 / 255 << " độ\n"; }
};

// Hàm này viết MỘT LẦN, chạy đúng với MỌI loại động cơ – đó là đa hình
void khoiDong(DongCo& dc, int tocDo) { dc.chay(tocDo); }

int main() {
    std::cout << "== Liên kết động: hàm nào được gọi do KIỂU THẬT của đối tượng quyết định ==\n";
    DongCoDC dc;
    DongCoBuoc buoc;
    Servo servo;
    DongCo* ds[] = {&dc, &buoc, &servo};
    for (DongCo* p : ds) p->chay(128);

    std::cout << "\n== Qua tham chiếu cũng vậy ==\n";
    khoiDong(buoc, 200);

    std::cout << "\n== Hàm KHÔNG ảo: gọi theo KIỂU CON TRỎ (liên kết tĩnh) ==\n";
    DongCo* p = &dc;
    p->tenLop();      // gọi bản của DongCo dù đối tượng là DongCoDC
    dc.tenLop();

    std::cout << "\n== Destructor ảo: xoá qua con trỏ lớp cha vẫn gọi đủ destructor lớp con ==\n";
    {
        std::unique_ptr<DongCo> dongCo = std::make_unique<DongCoDC>();
        dongCo->chay(255);
    }

    std::cout << "\n== Chi phí của đa hình ==\n";
    struct KhongAo { int x; };
    struct CoAo { virtual ~CoAo() = default; int x; };
    std::cout << "  sizeof(lớp không ảo) = " << sizeof(KhongAo) << ", sizeof(lớp có hàm ảo) = " << sizeof(CoAo)
              << " (thêm con trỏ vtable)\n";
    std::cout << "\n== Hết main ==\n";
}

// Tính trừu tượng: lớp trừu tượng (hàm thuần ảo = 0) và interface
#include <cstdio>
#include <iostream>
#include <string>

// INTERFACE: chỉ có hàm thuần ảo – mô tả "làm được gì", không nói "làm thế nào"
class IHienThi {
public:
    virtual ~IHienThi() = default;
    virtual void xoa() = 0;
    virtual void inDong(int dong, const std::string& s) = 0;
};

class IGhiLog {
public:
    virtual ~IGhiLog() = default;
    virtual void ghi(const std::string& s) = 0;
};

// LỚP TRỪU TƯỢNG: có cả hàm thuần ảo lẫn code dùng chung
class CamBien {
public:
    virtual ~CamBien() = default;
    virtual float doc() = 0;                       // lớp con BẮT BUỘC cài đặt
    virtual std::string donVi() const = 0;
    std::string docChuoi() {                       // code chung, dùng hàm trừu tượng ở trên
        char buf[16];
        std::snprintf(buf, sizeof(buf), "%.1f", doc());
        return buf + donVi();
    }
};

// ===== Các lớp cụ thể =====
class Lcd1602 : public IHienThi {
public:
    void xoa() override { std::cout << "  [LCD] xoá màn hình\n"; }
    void inDong(int d, const std::string& s) override { std::cout << "  [LCD dòng " << d << "] " << s << "\n"; }
};
class SerialMonitor : public IHienThi, public IGhiLog {    // một lớp cài nhiều interface
public:
    void xoa() override {}
    void inDong(int d, const std::string& s) override { std::cout << "  [Serial] " << d << ": " << s << "\n"; }
    void ghi(const std::string& s) override { std::cout << "  [Serial LOG] " << s << "\n"; }
};
class Dht22 : public CamBien {
public:
    float doc() override { return 28.46f; }
    std::string donVi() const override { return "C"; }
};
class Bh1750 : public CamBien {
public:
    float doc() override { return 356.7f; }
    std::string donVi() const override { return " lux"; }
};

// Logic ứng dụng chỉ phụ thuộc vào TRỪU TƯỢNG -> đổi phần cứng không phải sửa hàm này
void capNhatManHinh(IHienThi& man, CamBien& nhiet, CamBien& anhSang) {
    man.xoa();
    man.inDong(0, "Nhiet do: " + nhiet.docChuoi());
    man.inDong(1, "Anh sang: " + anhSang.docChuoi());
}

int main() {
    Dht22 dht;
    Bh1750 bh;
    Lcd1602 lcd;
    SerialMonitor serial;

    std::cout << "== Cùng một hàm, hiển thị lên LCD ==\n";
    capNhatManHinh(lcd, dht, bh);
    std::cout << "\n== ... hoặc lên Serial Monitor, không sửa code ==\n";
    capNhatManHinh(serial, dht, bh);

    std::cout << "\n== Dùng qua interface khác ==\n";
    IGhiLog& log = serial;
    log.ghi("Khởi động xong");

    // CamBien cb;   // LỖI: không tạo được đối tượng từ lớp trừu tượng
    std::cout << "\n  Không thể tạo đối tượng CamBien trực tiếp vì nó có hàm thuần ảo.\n";
}

// Con trỏ lớp: con trỏ tới đối tượng, ->, this, Singleton bằng con trỏ static,
// thay đổi đối tượng đang dùng qua con trỏ (đổi chế độ lúc chạy)
#include <iostream>
#include <string>

class Robot {
public:
    explicit Robot(std::string ten) : ten_(std::move(ten)) {}
    Robot* tien(int cm) { x_ += cm; return this; }          // trả về this để gọi nối tiếp
    Robot* re(int doc)  { huong_ = (huong_ + doc) % 360; return this; }
    void baoCao() const { std::cout << "  " << ten_ << ": x = " << x_ << " cm, hướng " << huong_ << "°\n"; }
private:
    std::string ten_;
    int x_ = 0, huong_ = 0;
};

// ===== Singleton bằng con trỏ static (kiểu cổ điển) =====
class CauHinh {
public:
    static CauHinh* layThucThe() {
        if (thucThe_ == nullptr) {
            thucThe_ = new CauHinh();                         // tạo lần đầu
            std::cout << "  (tạo CauHinh)\n";
        }
        return thucThe_;
    }
    int nguongNhiet = 30;
private:
    CauHinh() = default;                                      // không cho new từ bên ngoài
    static CauHinh* thucThe_;
};
CauHinh* CauHinh::thucThe_ = nullptr;

// ===== Thay đổi đối tượng qua con trỏ: đổi "chế độ" lúc chạy =====
class CheDo {
public:
    virtual ~CheDo() = default;
    virtual void xuLy(float t) = 0;
};
class CheDoTietKiem : public CheDo {
public:
    void xuLy(float t) override { std::cout << "  [Tiết kiệm] " << t << "°C -> quạt " << (t > 32 ? "chậm" : "tắt") << "\n"; }
};
class CheDoManh : public CheDo {
public:
    void xuLy(float t) override { std::cout << "  [Mạnh] " << t << "°C -> quạt " << (t > 26 ? "MAX" : "vừa") << "\n"; }
};

int main() {
    std::cout << "== Con trỏ tới đối tượng và -> ==\n";
    Robot r("BK-01");
    Robot* p = &r;
    p->tien(20);                       // p->tien() tương đương (*p).tien()
    (*p).re(90);
    p->tien(10)->re(90)->tien(5);      // nối tiếp nhờ trả về this
    p->baoCao();

    std::cout << "\n== Mảng đối tượng & con trỏ duyệt mảng ==\n";
    Robot doi[3] = {Robot("R1"), Robot("R2"), Robot("R3")};
    for (Robot* it = doi; it != doi + 3; ++it) it->tien(10 * (it - doi + 1));
    for (const Robot& rb : doi) rb.baoCao();

    std::cout << "\n== Singleton: mọi nơi lấy về cùng một con trỏ ==\n";
    CauHinh* c1 = CauHinh::layThucThe();
    CauHinh* c2 = CauHinh::layThucThe();
    c1->nguongNhiet = 35;
    std::cout << "  c1 == c2 ? " << std::boolalpha << (c1 == c2) << ", c2->nguongNhiet = " << c2->nguongNhiet << "\n";

    std::cout << "\n== Đổi đối tượng mà con trỏ trỏ tới -> đổi hành vi lúc chạy ==\n";
    CheDoTietKiem tietKiem;
    CheDoManh manh;
    CheDo* cheDoHienTai = &tietKiem;
    for (float t : {28.0f, 33.0f}) cheDoHienTai->xuLy(t);
    std::cout << "  -- người dùng bấm nút đổi chế độ --\n";
    cheDoHienTai = &manh;                       // chỉ đổi con trỏ, không if/else
    for (float t : {28.0f, 33.0f}) cheDoHienTai->xuLy(t);
}

// Con trỏ lớp trong thiết kế: Adapter (bọc lớp có sẵn) và Abstract (làm việc qua con trỏ lớp trừu tượng)
#include <iostream>
#include <memory>
#include <vector>

// ===== Interface mà chương trình của ta dùng =====
class IKhoangCach {
public:
    virtual ~IKhoangCach() = default;
    virtual float docCm() = 0;
};

class SieuAmHcSr04 : public IKhoangCach {                  // đã tương thích sẵn
public:
    float docCm() override { return 42.0f; }
};

// ===== Thư viện bên thứ ba: trả về MILIMET với tên hàm khác, không sửa được =====
class VL53L0X {
public:
    int readRangeMillimeters() { return 875; }
};

// ===== Adapter: giữ CON TRỎ tới đối tượng cũ, chuyển lời gọi + đổi đơn vị =====
class VL53Adapter : public IKhoangCach {
public:
    explicit VL53Adapter(VL53L0X* cb) : cb_(cb) {}
    float docCm() override { return cb_->readRangeMillimeters() / 10.0f; }
private:
    VL53L0X* cb_;
};

// ===== Abstract: robot chỉ cầm con trỏ tới IKhoangCach =====
class RobotTranhVatCan {
public:
    void them(std::unique_ptr<IKhoangCach> cb) { camBien_.push_back(std::move(cb)); }
    void buoc() {
        float gan = 1e9;
        for (auto& cb : camBien_) {                       // gọi qua con trỏ lớp trừu tượng
            float d = cb->docCm();
            std::cout << "  cảm biến báo " << d << " cm\n";
            if (d < gan) gan = d;
        }
        std::cout << "  -> vật cản gần nhất " << gan << " cm: " << (gan < 50 ? "RẼ" : "đi thẳng") << "\n";
    }
private:
    std::vector<std::unique_ptr<IKhoangCach>> camBien_;
};

int main() {
    static VL53L0X laser;                                  // đối tượng thư viện
    RobotTranhVatCan robot;
    robot.them(std::make_unique<SieuAmHcSr04>());
    robot.them(std::make_unique<VL53Adapter>(&laser));   // bọc bằng adapter rồi dùng như mọi cảm biến khác
    robot.buoc();

    std::cout << "\n  Xem thêm khóa Design Pattern: Adapter, Singleton, Strategy, State.\n";
}

// File I/O và Stream: ghi/đọc file văn bản (CSV log), ghi thêm, file nhị phân
// (Trên ESP32 dùng y hệt với thẻ SD hoặc LittleFS qua thư viện File/FS)
#include <fstream>
#include <iostream>
#include <sstream>
#include <string>

struct BanGhi { int giay; float nhietDo; int doAm; };

int main() {
    std::cout << "== Ghi file CSV ==\n";
    {
        std::ofstream f("log.csv");                       // mở để GHI (xoá nội dung cũ)
        if (!f) { std::cerr << "Không mở được file\n"; return 1; }
        f << "giay,nhiet_do,do_am\n";
        BanGhi duLieu[] = {{0, 28.5f, 60}, {10, 28.9f, 61}, {20, 29.4f, 59}};
        for (const auto& b : duLieu) f << b.giay << "," << b.nhietDo << "," << b.doAm << "\n";
    }                                                     // ra khỏi khối -> file tự đóng (RAII)
    std::cout << "  đã ghi log.csv\n";

    std::cout << "\n== Ghi THÊM vào cuối file (append) ==\n";
    {
        std::ofstream f("log.csv", std::ios::app);
        f << 30 << "," << 30.1 << "," << 58 << "\n";
    }

    std::cout << "\n== Đọc lại từng dòng và phân tích CSV ==\n";
    std::ifstream in("log.csv");
    std::string dong;
    std::getline(in, dong);                               // bỏ dòng tiêu đề
    float tong = 0;
    int n = 0;
    while (std::getline(in, dong)) {
        std::stringstream ss(dong);
        std::string o;
        BanGhi b{};
        std::getline(ss, o, ','); b.giay = std::stoi(o);
        std::getline(ss, o, ','); b.nhietDo = std::stof(o);
        std::getline(ss, o, ','); b.doAm = std::stoi(o);
        std::cout << "  t=" << b.giay << "s  T=" << b.nhietDo << "  H=" << b.doAm << "\n";
        tong += b.nhietDo;
        n++;
    }
    std::cout << "  Nhiệt độ trung bình: " << tong / n << "\n";

    std::cout << "\n== File nhị phân: lưu cấu hình (giống EEPROM.put/get) ==\n";
    struct CauHinh { int nguong; float heSo; char wifi[16]; };
    CauHinh luu{32, 1.05f, "BKSTAR-Lab"};
    std::ofstream fb("config.bin", std::ios::binary);
    fb.write(reinterpret_cast<const char*>(&luu), sizeof(luu));
    fb.close();

    CauHinh doc{};
    std::ifstream fr("config.bin", std::ios::binary);
    fr.read(reinterpret_cast<char*>(&doc), sizeof(doc));
    std::cout << "  đọc lại: nguong=" << doc.nguong << ", heSo=" << doc.heSo << ", wifi=" << doc.wifi
              << " (" << fr.gcount() << " byte)\n";

    std::cout << "\n== Mở file không tồn tại ==\n";
    std::ifstream khong("khong_co.txt");
    std::cout << "  is_open() = " << std::boolalpha << khong.is_open() << " -> luôn kiểm tra!\n";
}

// Xử lý ngoại lệ: try / catch / throw, lớp ngoại lệ riêng – và cách thay thế khi firmware tắt exception
#include <iostream>
#include <optional>
#include <stdexcept>
#include <string>
#include <vector>

class LoiCamBien : public std::runtime_error {             // ngoại lệ tự định nghĩa
public:
    LoiCamBien(const std::string& ten, int maLoi)
        : std::runtime_error("Cảm biến " + ten + " lỗi mã " + std::to_string(maLoi)), maLoi(maLoi) {}
    int maLoi;
};

float docNhietDo(int lanThu) {
    if (lanThu == 2) throw LoiCamBien("DHT22", 4);         // NÉM ngoại lệ
    if (lanThu == 3) throw std::out_of_range("giá trị ngoài dải -40..80");
    return 27.5f + lanThu;
}

int chia(int a, int b) {
    if (b == 0) throw std::invalid_argument("chia cho 0");
    return a / b;
}

// Cách KHÔNG dùng exception (phổ biến trong firmware biên dịch với -fno-exceptions)
std::optional<float> docNhietDoAnToan(int lanThu) {
    if (lanThu == 2) return std::nullopt;                  // "không có giá trị" = lỗi
    return 27.5f + lanThu;
}

int main() {
    std::cout << "== try / catch nhiều loại ngoại lệ ==\n";
    for (int i = 1; i <= 4; i++) {
        try {
            float t = docNhietDo(i);
            std::cout << "  lần " << i << ": " << t << "°C\n";
        } catch (const LoiCamBien& e) {                    // bắt loại cụ thể trước
            std::cout << "  lần " << i << ": " << e.what() << " -> khởi động lại cảm biến\n";
        } catch (const std::exception& e) {                // rồi tới loại tổng quát
            std::cout << "  lần " << i << ": lỗi chung: " << e.what() << "\n";
        }
    }

    std::cout << "\n== Ngoại lệ của thư viện chuẩn ==\n";
    try {
        std::vector<int> v = {1, 2, 3};
        int x = v.at(10);                                  // ném ngoại lệ ở đây, dòng dưới không chạy
        std::cout << "  v.at(10) = " << x << "\n";
    } catch (const std::out_of_range&) {
        std::cout << "  v.at(10) ném std::out_of_range\n";
    }
    try {
        std::stoi("abc");
    } catch (const std::invalid_argument&) {
        std::cout << "  stoi(\"abc\") ném std::invalid_argument\n";
    }
    try {
        std::cout << "  chia(10, 2) = " << chia(10, 2) << "\n";
        int kq = chia(1, 0);
        std::cout << "  chia(1, 0) = " << kq << "\n";
    } catch (const std::invalid_argument& e) {
        std::cout << "  bắt được: " << e.what() << "\n";
    }

    std::cout << "\n== Không dùng exception: std::optional ==\n";
    for (int i = 1; i <= 2; i++) {
        if (auto t = docNhietDoAnToan(i)) std::cout << "  lần " << i << ": " << *t << "°C\n";
        else                              std::cout << "  lần " << i << ": đọc lỗi, dùng giá trị cũ\n";
    }
}

// Bộ nhớ động: stack vs heap, new/delete, rò rỉ bộ nhớ, con trỏ thông minh, placement new vào bộ đệm tĩnh
#include <iostream>
#include <memory>
#include <new>

class GoiTin {
public:
    explicit GoiTin(int id) : id_(id) { soDangSong++; std::cout << "    + GoiTin " << id_ << "\n"; }
    ~GoiTin() { soDangSong--; std::cout << "    - GoiTin " << id_ << "\n"; }
    int id() const { return id_; }
    static int soDangSong;
private:
    int id_;
    char payload_[60] = {};
};
int GoiTin::soDangSong = 0;

int main() {
    std::cout << "== Stack: biến cục bộ tự giải phóng ==\n";
    {
        GoiTin g(1);
    }

    std::cout << "\n== Heap với new / delete ==\n";
    GoiTin* p = new GoiTin(2);              // cấp phát trên heap, sống tới khi delete
    std::cout << "    dùng p->id() = " << p->id() << "\n";
    delete p;                               // QUÊN dòng này = rò rỉ bộ nhớ
    p = nullptr;                            // tránh con trỏ treo (dangling)

    std::cout << "\n== Mảng động new[] / delete[] ==\n";
    int n = 5;                              // kích thước chỉ biết lúc chạy
    int* mau = new int[n];
    for (int i = 0; i < n; i++) mau[i] = i * i;
    std::cout << "    mau[4] = " << mau[4] << "\n";
    delete[] mau;                           // mảng phải dùng delete[]

    std::cout << "\n== Rò rỉ bộ nhớ (memory leak) ==\n";
    for (int i = 0; i < 3; i++) {
        GoiTin* ro = new GoiTin(10 + i);    // cố ý không delete
        (void)ro;
    }
    std::cout << "    Còn " << GoiTin::soDangSong << " gói tin không ai giải phóng! (trên MCU sẽ cạn RAM dần rồi treo)\n";

    std::cout << "\n== unique_ptr: một chủ sở hữu, tự delete ==\n";
    {
        std::unique_ptr<GoiTin> u = std::make_unique<GoiTin>(20);
        std::unique_ptr<GoiTin> u2 = std::move(u);      // chuyển quyền sở hữu, không sao chép được
        std::cout << "    u rỗng? " << std::boolalpha << (u == nullptr) << ", u2->id() = " << u2->id() << "\n";
    }

    std::cout << "\n== shared_ptr: nhiều chủ sở hữu, đếm tham chiếu ==\n";
    {
        auto s1 = std::make_shared<GoiTin>(30);
        {
            auto s2 = s1;
            std::cout << "    use_count = " << s1.use_count() << "\n";
        }
        std::cout << "    use_count = " << s1.use_count() << "\n";
    }

    std::cout << "\n== Placement new: dựng đối tượng trong bộ đệm TĨNH (không đụng heap) ==\n";
    alignas(GoiTin) static unsigned char vungNho[sizeof(GoiTin)];
    GoiTin* g = new (vungNho) GoiTin(40);
    std::cout << "    đối tượng nằm trong vungNho? " << (static_cast<void*>(g) == vungNho) << "\n";
    g->~GoiTin();                           // tự gọi destructor, KHÔNG delete

    std::cout << "\n  sizeof(GoiTin) = " << sizeof(GoiTin) << " byte. Arduino Uno chỉ có 2048 byte RAM!\n";
    std::cout << "  Còn sống ở cuối chương trình: " << GoiTin::soDangSong << " (chính là 3 gói bị rò rỉ)\n";
}

// Namespace: tránh trùng tên khi ghép nhiều thư viện
#include <iostream>

namespace dht {
    float doc() { return 28.4f; }
    const char* ten = "DHT22";
}

namespace bmp {
    float doc() { return 1012.7f; }          // cùng tên doc() nhưng không xung đột
    const char* ten = "BMP280";
    namespace hieuChinh {                     // namespace lồng nhau
        float heSo = 1.002f;
    }
}

namespace robot::dongCo {                     // cú pháp lồng gọn (C++17)
    void chay() { std::cout << "  robot::dongCo::chay()\n"; }
}

namespace {                                   // namespace ẩn danh: chỉ thấy trong file này (như static)
    int biMat = 42;
}

namespace dongCoRatDaiTen { void dung() { std::cout << "  dừng động cơ\n"; } }

int main() {
    std::cout << "== Gọi bằng tên đầy đủ ==\n";
    std::cout << "  " << dht::ten << ": " << dht::doc() << "\n";
    std::cout << "  " << bmp::ten << ": " << bmp::doc() * bmp::hieuChinh::heSo << "\n";
    robot::dongCo::chay();

    std::cout << "\n== using: đưa MỘT tên vào phạm vi hiện tại ==\n";
    using std::cout;
    cout << "  dùng cout không cần std::\n";

    std::cout << "\n== Bí danh namespace ==\n";
    namespace dc = dongCoRatDaiTen;
    dc::dung();

    std::cout << "\n== Namespace ẩn danh ==\n";
    std::cout << "  biMat = " << biMat << "\n";

    std::cout << "\n  Lưu ý: tránh viết 'using namespace std;' trong file .h – dễ gây trùng tên ở nơi include.\n";
}

// Template: hàm mẫu, lớp mẫu, tham số không phải kiểu (kích thước), chuyên biệt hoá
#include <cstdint>
#include <iostream>
#include <string>

// ===== Hàm mẫu: viết một lần, dùng cho nhiều kiểu =====
template <typename T>
T lonNhat(T a, T b) { return a > b ? a : b; }

template <typename T>
T gioiHan(T x, T thap, T cao) { return x < thap ? thap : (x > cao ? cao : x); }

// ===== Lớp mẫu: bộ đệm vòng kích thước cố định – KHÔNG dùng heap, rất hợp vi điều khiển =====
template <typename T, size_t N>
class RingBuffer {
public:
    bool push(const T& v) {
        if (dem_ == N) return false;              // đầy
        buf_[duoi_] = v;
        duoi_ = (duoi_ + 1) % N;
        dem_++;
        return true;
    }
    bool pop(T& ra) {
        if (dem_ == 0) return false;              // rỗng
        ra = buf_[dau_];
        dau_ = (dau_ + 1) % N;
        dem_--;
        return true;
    }
    size_t size() const { return dem_; }
    static constexpr size_t capacity() { return N; }
private:
    T buf_[N];
    size_t dau_ = 0, duoi_ = 0, dem_ = 0;
};

// ===== Chuyên biệt hoá: xử lý riêng cho một kiểu =====
template <typename T>
std::string moTa(const T& v) { return "giá trị " + std::to_string(v); }
template <>
std::string moTa<bool>(const bool& v) { return v ? "BẬT" : "TẮT"; }

int main() {
    std::cout << "== Hàm mẫu ==\n";
    std::cout << "  lonNhat(3, 7) = " << lonNhat(3, 7) << "\n";
    std::cout << "  lonNhat(2.5, 1.5) = " << lonNhat(2.5, 1.5) << "\n";
    std::cout << "  lonNhat<std::string>(\"abc\", \"abd\") = " << lonNhat<std::string>("abc", "abd") << "\n";
    std::cout << "  gioiHan(300, 0, 255) = " << gioiHan(300, 0, 255) << "\n";

    std::cout << "\n== Lớp mẫu RingBuffer<uint16_t, 4> ==\n";
    RingBuffer<uint16_t, 4> hangDoiAdc;
    for (uint16_t v : {100, 200, 300, 400, 500}) {
        bool ok = hangDoiAdc.push(v);
        std::cout << "  push " << v << (ok ? " ok" : " -> ĐẦY, bỏ qua") << "\n";
    }
    uint16_t v;
    while (hangDoiAdc.pop(v)) std::cout << "  pop " << v << "\n";
    std::cout << "  sizeof(RingBuffer<uint16_t,4>) = " << sizeof(hangDoiAdc) << " byte, cố định lúc biên dịch\n";

    RingBuffer<std::string, 2> lenh;
    lenh.push("LED:1");
    std::string s;
    lenh.pop(s);
    std::cout << "  RingBuffer<std::string, 2> dùng cho lệnh: " << s << "\n";

    std::cout << "\n== Chuyên biệt hoá ==\n";
    std::cout << "  moTa(42) = " << moTa(42) << ", moTa(true) = " << moTa(true) << "\n";
}

// Bộ tiền xử lý (preprocessor): #define, macro, biên dịch có điều kiện, macro có sẵn
// Chạy TRƯỚC khi biên dịch: chỉ thay thế văn bản, không hiểu kiểu dữ liệu.
#include <iostream>

#define LED_PIN 13                       // hằng kiểu C (C++ nên dùng constexpr)
#define BINH_PHUONG_SAI(x) x * x         // macro thiếu ngoặc -> bẫy!
#define BINH_PHUONG(x) ((x) * (x))
#define DEBUG 1                          // bật/tắt log khi biên dịch
#define BOARD_ESP32                      // chọn phần cứng

#if DEBUG
  #define LOG(msg) std::cout << "  [DEBUG " << __FILE__ << ":" << __LINE__ << "] " << msg << "\n"
#else
  #define LOG(msg)                       // bản phát hành: log biến mất hoàn toàn, không tốn byte nào
#endif

#ifdef BOARD_ESP32
  constexpr int ADC_MAX = 4095;          // 12 bit
  constexpr const char* TEN_BOARD = "ESP32";
#elif defined(BOARD_UNO)
  constexpr int ADC_MAX = 1023;          // 10 bit
  constexpr const char* TEN_BOARD = "Arduino Uno";
#else
  #error "Chưa chọn board!"
#endif

#define CHUOI_HOA(x) #x                  // toán tử # biến tham số thành chuỗi
#define NOI(a, b) a##b                   // toán tử ## nối hai token

int main() {
    std::cout << "== #define hằng ==\n";
    std::cout << "  LED_PIN = " << LED_PIN << "\n";

    std::cout << "\n== Macro hàm và bẫy thiếu ngoặc ==\n";
    std::cout << "  BINH_PHUONG_SAI(2 + 3) = " << BINH_PHUONG_SAI(2 + 3) << "  (thành 2 + 3 * 2 + 3!)\n";
    std::cout << "  BINH_PHUONG(2 + 3)     = " << BINH_PHUONG(2 + 3) << "\n";

    std::cout << "\n== Biên dịch có điều kiện ==\n";
    std::cout << "  Board: " << TEN_BOARD << ", ADC_MAX = " << ADC_MAX << "\n";
    LOG("khởi động xong");

    std::cout << "\n== # và ## ==\n";
    int NOI(dem, 1) = 5;                 // tạo biến tên dem1
    std::cout << "  " << CHUOI_HOA(dem1) << " = " << dem1 << "\n";

    std::cout << "\n== Macro có sẵn ==\n";
    std::cout << "  __cplusplus = " << __cplusplus << " (201703 = C++17)\n";
    std::cout << "  __func__    = " << __func__ << "\n";
#ifdef __GNUC__
    std::cout << "  Trình biên dịch: GCC " << __GNUC__ << "\n";
#endif

    std::cout << "\n  Include guard trong file .h:\n"
                 "    #ifndef CAM_BIEN_H\n    #define CAM_BIEN_H\n    ...\n    #endif   (hoặc #pragma once)\n";
}

// Xử lý tín hiệu (signal): hệ điều hành báo sự kiện bất đồng bộ cho chương trình
// Ý tưởng rất giống NGẮT (interrupt) trên vi điều khiển: handler phải ngắn, chỉ đặt cờ.
#include <csignal>
#include <iostream>

volatile std::sig_atomic_t coDung = 0;      // kiểu an toàn để ghi trong signal handler
volatile std::sig_atomic_t soLanNhan = 0;

void xuLyTinHieu(int maTinHieu) {           // signal handler: KHÔNG in, KHÔNG cấp phát ở đây
    soLanNhan++;
    if (maTinHieu == SIGINT) coDung = 1;
}

int main() {
    std::signal(SIGINT, xuLyTinHieu);       // đăng ký: khi nhấn Ctrl+C -> gọi xuLyTinHieu
    std::signal(SIGTERM, xuLyTinHieu);

    std::cout << "== Vòng lặp chính chạy tới khi nhận SIGINT ==\n";
    for (int vong = 1; !coDung; vong++) {
        std::cout << "  vòng " << vong << ": đọc cảm biến, cập nhật màn hình\n";
        if (vong == 3) {
            std::cout << "  (giả lập người dùng nhấn Ctrl+C)\n";
            std::raise(SIGINT);              // tự gửi tín hiệu cho chính chương trình
        }
    }
    std::cout << "  Nhận tín hiệu " << soLanNhan << " lần -> lưu dữ liệu, đóng file, thoát an toàn\n";

    std::cout << "\n== Một số tín hiệu chuẩn ==\n";
    std::cout << "  SIGINT  = " << SIGINT  << "  ngắt từ bàn phím (Ctrl+C)\n";
    std::cout << "  SIGTERM = " << SIGTERM << " yêu cầu kết thúc\n";
    std::cout << "  SIGSEGV = " << SIGSEGV << " truy cập bộ nhớ sai (con trỏ hỏng)\n";
    std::cout << "  SIGFPE  = " << SIGFPE  << "  lỗi số học (chia nguyên cho 0)\n";
    std::cout << "  SIGABRT = " << SIGABRT << " abort()\n";

    std::signal(SIGINT, SIG_DFL);            // trả về xử lý mặc định
    return 0;
}

// Đa luồng (multithread): std::thread, data race, mutex, atomic, producer–consumer với condition_variable
// Cùng các khái niệm này sẽ gặp lại trong khóa FreeRTOS (task, mutex, queue).
#include <atomic>
#include <condition_variable>
#include <iostream>
#include <mutex>
#include <queue>
#include <thread>
#include <vector>

int demKhongAnToan = 0;
int demCoMutex = 0;
std::atomic<int> demAtomic{0};
std::mutex khoa;

void tangKhongAnToan() { for (int i = 0; i < 100000; i++) demKhongAnToan++; }   // data race!
void tangCoMutex()     { for (int i = 0; i < 100000; i++) { std::lock_guard<std::mutex> lk(khoa); demCoMutex++; } }
void tangAtomic()      { for (int i = 0; i < 100000; i++) demAtomic++; }

int main() {
    std::cout << "== Tạo và join luồng ==\n";
    std::thread t([] { std::cout << "  xin chào từ luồng phụ\n"; });
    t.join();                                       // chờ luồng phụ kết thúc
    std::cout << "  luồng chính tiếp tục\n";

    std::cout << "\n== 4 luồng cùng tăng một biến 100 000 lần (kỳ vọng 400 000) ==\n";
    auto chay4 = [](void (*f)()) {
        std::vector<std::thread> ds;
        for (int i = 0; i < 4; i++) ds.emplace_back(f);
        for (auto& th : ds) th.join();
    };
    chay4(tangKhongAnToan);
    chay4(tangCoMutex);
    chay4(tangAtomic);
    std::cout << "  không bảo vệ : " << (demKhongAnToan == 400000 ? "400000 (may mắn)" : "SAI – bị mất lượt cộng") << "\n";
    std::cout << "  có mutex     : " << demCoMutex << "\n";
    std::cout << "  std::atomic  : " << demAtomic << "\n";

    std::cout << "\n== Producer–consumer: luồng đọc cảm biến -> hàng đợi -> luồng xử lý ==\n";
    std::queue<int> hangDoi;
    std::mutex m;
    std::condition_variable cv;
    bool xong = false;

    std::thread sanXuat([&] {
        for (int i = 1; i <= 5; i++) {
            {
                std::lock_guard<std::mutex> lk(m);
                hangDoi.push(500 + i * 10);
            }
            cv.notify_one();                         // đánh thức consumer
        }
        { std::lock_guard<std::mutex> lk(m); xong = true; }
        cv.notify_one();
    });
    std::thread tieuThu([&] {
        while (true) {
            std::unique_lock<std::mutex> lk(m);
            cv.wait(lk, [&] { return !hangDoi.empty() || xong; });   // ngủ tới khi có dữ liệu
            while (!hangDoi.empty()) {
                std::cout << "  xử lý mẫu " << hangDoi.front() << "\n";
                hangDoi.pop();
            }
            if (xong) break;
        }
    });
    sanXuat.join();
    tieuThu.join();
    std::cout << "  Phần cứng có " << std::thread::hardware_concurrency() << " luồng; ESP32 có 2 nhân\n";
}

// Thư viện STL: container (vector, map, set, queue, stack), iterator, thuật toán, lambda
#include <algorithm>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>

int main() {
    std::cout << "== vector: mảng động ==\n";
    std::vector<int> mau = {512, 498, 530, 1023, 505, 487};
    mau.push_back(520);
    std::cout << "  size = " << mau.size() << ", phần tử cuối = " << mau.back() << "\n";
    mau.erase(std::remove(mau.begin(), mau.end(), 1023), mau.end());     // xoá giá trị nhiễu
    std::cout << "  sau khi bỏ 1023: ";
    for (int v : mau) std::cout << v << " ";
    std::cout << "\n";

    std::cout << "\n== <algorithm> & <numeric> ==\n";
    std::vector<int> sapXep = mau;
    std::sort(sapXep.begin(), sapXep.end());
    std::cout << "  sort: ";
    for (int v : sapXep) std::cout << v << " ";
    std::cout << "\n  min = " << *std::min_element(mau.begin(), mau.end())
              << ", max = " << *std::max_element(mau.begin(), mau.end())
              << ", tổng = " << std::accumulate(mau.begin(), mau.end(), 0)
              << ", trung vị = " << sapXep[sapXep.size() / 2] << "\n";
    int tren500 = std::count_if(mau.begin(), mau.end(), [](int v) { return v > 500; });
    std::cout << "  số mẫu > 500: " << tren500 << "\n";
    auto it = std::find(mau.begin(), mau.end(), 530);
    std::cout << "  tìm 530 ở vị trí " << (it - mau.begin()) << "\n";
    std::sort(sapXep.begin(), sapXep.end(), [](int a, int b) { return a > b; });
    std::cout << "  sắp giảm dần bằng lambda: " << sapXep.front() << " ... " << sapXep.back() << "\n";

    std::cout << "\n== map: từ điển có thứ tự (khoá -> giá trị) ==\n";
    std::map<std::string, int> chanThietBi = {{"led", 2}, {"coi", 4}, {"servo", 18}};
    chanThietBi["quat"] = 23;
    for (const auto& [ten, chan] : chanThietBi) std::cout << "  " << ten << " -> chân " << chan << "\n";
    std::cout << "  có 'relay'? " << std::boolalpha << (chanThietBi.count("relay") > 0) << "\n";

    std::cout << "\n== unordered_map: đếm tần suất lệnh ==\n";
    std::unordered_map<char, int> dem;
    for (char c : std::string("FFLFRBFFS")) dem[c]++;
    std::cout << "  lệnh 'F' xuất hiện " << dem['F'] << " lần\n";

    std::cout << "\n== set: tập hợp không trùng, tự sắp xếp ==\n";
    std::set<int> diaChiI2C = {0x76, 0x3C, 0x68, 0x3C};
    std::cout << "  thiết bị I2C:";
    for (int a : diaChiI2C) std::cout << " 0x" << std::hex << a << std::dec;
    std::cout << " (" << diaChiI2C.size() << " thiết bị)\n";

    std::cout << "\n== queue (FIFO) và stack (LIFO) ==\n";
    std::queue<std::string> lenh;
    lenh.push("tiến"); lenh.push("rẽ trái"); lenh.push("dừng");
    std::cout << "  queue lấy ra: ";
    while (!lenh.empty()) { std::cout << lenh.front() << " | "; lenh.pop(); }
    std::stack<std::string> lichSu;
    lichSu.push("mở menu"); lichSu.push("chọn WiFi"); lichSu.push("nhập mật khẩu");
    std::cout << "\n  stack (nút Back): ";
    while (!lichSu.empty()) { std::cout << lichSu.top() << " | "; lichSu.pop(); }
    std::cout << "\n";

    std::cout << "\n== priority_queue: lấy việc ưu tiên cao nhất trước ==\n";
    std::priority_queue<std::pair<int, std::string>> viec;
    viec.push({1, "cập nhật màn hình"});
    viec.push({9, "CẢNH BÁO CHÁY"});
    viec.push({5, "gửi dữ liệu MQTT"});
    while (!viec.empty()) { std::cout << "  [" << viec.top().first << "] " << viec.top().second << "\n"; viec.pop(); }
}

// Một vòng thư viện chuẩn C++ hay dùng: <optional>, <variant>, <tuple>, <string_view>, <bitset>,
// <array>, <functional>, <cstring>/<cstdlib> (thư viện C) – và ghép lại thành bộ phân tích gói tin
#include <array>
#include <bitset>
#include <cstdint>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <optional>
#include <string>
#include <string_view>
#include <tuple>
#include <variant>

// string_view: "nhìn" vào chuỗi có sẵn, không sao chép – tiết kiệm RAM
std::string_view layTen(std::string_view lenh) { return lenh.substr(0, lenh.find(':')); }

// tuple / structured binding: trả về nhiều giá trị
std::tuple<float, float, bool> docDht() { return {28.6f, 64.0f, true}; }

// variant: một biến chứa MỘT trong nhiều kiểu (an toàn hơn union)
using GiaTri = std::variant<int, float, std::string>;
void inGiaTri(const GiaTri& g) {
    if (auto p = std::get_if<int>(&g))              std::cout << "  int: " << *p << "\n";
    else if (auto p = std::get_if<float>(&g))       std::cout << "  float: " << *p << "\n";
    else                                            std::cout << "  string: " << std::get<std::string>(g) << "\n";
}

// optional: có thể "không có giá trị"
std::optional<int> timChan(std::string_view ten) {
    if (ten == "led") return 2;
    if (ten == "coi") return 4;
    return std::nullopt;
}

int main() {
    std::cout << "== string_view ==\n";
    std::cout << "  layTen(\"SERVO:90\") = " << layTen("SERVO:90") << "\n";

    std::cout << "\n== tuple + structured binding ==\n";
    auto [t, h, ok] = docDht();
    std::cout << "  T = " << t << ", H = " << h << ", hợp lệ = " << std::boolalpha << ok << "\n";

    std::cout << "\n== variant ==\n";
    for (GiaTri g : {GiaTri{42}, GiaTri{3.5f}, GiaTri{std::string("OK")}}) inGiaTri(g);

    std::cout << "\n== optional ==\n";
    for (auto ten : {"led", "relay"}) {
        auto chan = timChan(ten);
        std::cout << "  " << ten << " -> " << (chan ? "chân " + std::to_string(*chan) : "không có") << "\n";
    }
    std::cout << "  value_or: " << timChan("relay").value_or(-1) << "\n";

    std::cout << "\n== bitset: thao tác cờ trạng thái ==\n";
    std::bitset<8> co;                       // 8 cờ: bit0 WiFi, bit1 MQTT, bit2 SD...
    co.set(0); co.set(2);
    std::cout << "  co = " << co << ", số cờ bật = " << co.count() << ", MQTT? " << co.test(1) << "\n";

    std::cout << "\n== Thư viện C trong C++: <cstring>, <cstdlib> ==\n";
    char goi[] = "T=28;H=64;P=1012";
    for (char* tok = std::strtok(goi, ";"); tok; tok = std::strtok(nullptr, ";")) {
        std::cout << "  " << tok[0] << " = " << std::atoi(tok + 2) << "\n";
    }
    std::array<uint8_t, 4> a{}, b{};
    a = {1, 2, 3, 4};
    std::memcpy(b.data(), a.data(), a.size());
    std::cout << "  memcpy xong, memcmp = " << std::memcmp(a.data(), b.data(), 4) << " (0 = giống nhau)\n";
}