Con Trỏ
Từ Số 0

#include <stdio.h>

int main() {
    int x = 42;          // biến bình thường
    int *p = &x;         // p lưu ĐỊA CHỈ của x

    printf("Giá trị x  = %d\n", x);
    printf("Địa chỉ x = %p\n", (void*)&x);
    printf("p chứa    = %p\n", (void*)p);
    printf("*p        = %d\n", *p);   // truy cập qua con trỏ

    return 0;
}

#include <stdio.h>

int main() {
    int x = 10;
    int *p = &x;

    printf("Trước: x = %d\n", x);
    *p = 99;   // GHI qua con trỏ — thay đổi x!
    printf("Sau:   x = %d\n", x);

    return 0;
}

int arr[] = {10, 20, 30};
int *p = arr;

printf("%d\n", *p);       // 10  (arr[0])
printf("%d\n", *(p+1));   // 20  (arr[1]) — cộng 4 bytes
printf("%d\n", *(p+2));   // 30  (arr[2]) — cộng 8 bytes
p++;                      // p giờ trỏ tới arr[1]

#include <stdio.h>

int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int *p = arr;   // không cần & vì arr đã là con trỏ

    // 3 cách truy cập arr[2] — tất cả đều giống nhau!
    printf("%d\n", arr[2]);      // Cách 1: chỉ số mảng
    printf("%d\n", *(arr+2));    // Cách 2: pointer arithmetic
    printf("%d\n", p[2]);        // Cách 3: dùng con trỏ như mảng

    // Duyệt mảng bằng con trỏ
    printf("Mảng: ");
    for (int i = 0; i < 5; i++) {
        printf("%d ", *(p++));
    }
    return 0;
}

#include <stdio.h>

// ❌ Không hoạt động — chỉ đổi bản sao!
void swap_wrong(int a, int b) {
    int tmp = a;
    a = b;
    b = tmp;
    // a, b là local — khi return, thay đổi mất!
}

// ✅ Đúng — truyền địa chỉ, thay đổi giá trị gốc
void swap(int *a, int *b) {
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

int main() {
    int x = 5, y = 10;

    swap_wrong(x, y);
    printf("Sau swap_wrong: x=%d y=%d\n", x, y); // 5 10 (không đổi!)

    swap(&x, &y);
    printf("Sau swap:       x=%d y=%d\n", x, y); // 10 5 ✓

    return 0;
}

// Hàm tìm min và max cùng lúc
void minmax(int *arr, int n, int *min, int *max) {
    *min = *max = arr[0];
    for (int i = 1; i < n; i++) {
        if (arr[i] < *min) *min = arr[i];
        if (arr[i] > *max) *max = arr[i];
    }
}

int main() {
    int data[] = {3, 7, 1, 9, 4};
    int lo, hi;
    minmax(data, 5, &lo, &hi);
    printf("Min=%d, Max=%d\n", lo, hi);
}

#include <stdio.h>

// Đếm độ dài chuỗi bằng con trỏ
int my_strlen(const char *s) {
    const char *p = s;
    while (*p != '\0') p++;
    return (int)(p - s);
}

// Đảo ngược chuỗi
void reverse_str(char *s) {
    char *end = s;
    while (*end) end++;
    end--;
    while (s < end) {
        char tmp = *s;
        *s++ = *end;
        *end-- = tmp;
    }
}

int main() {
    char s[] = "hello";
    printf("Độ dài: %d\n", my_strlen(s));
    reverse_str(s);
    printf("Đảo ngược: %s\n", s);
}

#include <stdio.h>
#include <stdlib.h>

int main() {
    int n;
    printf("Nhập số phần tử: ");
    scanf("%d", &n);

    // Cấp phát n ô nhớ kiểu int trên heap
    int *arr = (int*) malloc(n * sizeof(int));
    if (arr == NULL) {
        printf("Lỗi cấp phát bộ nhớ!\n");
        return 1;
    }

    for (int i = 0; i < n; i++)
        arr[i] = i * i;   // bình phương

    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);

    free(arr);   // BẮT BUỘC — tránh memory leak!
    arr = NULL; // Good practice sau khi free
    return 0;
}

#include <stdio.h>

int add(int a, int b) { return a + b; }
int mul(int a, int b) { return a * b; }
int sub(int a, int b) { return a - b; }

// Hàm nhận con trỏ hàm làm tham số
void apply(int x, int y, int (*op)(int, int), const char *name) {
    printf("%s(%d, %d) = %d\n", name, x, y, op(x, y));
}

int main() {
    // Khai báo mảng con trỏ hàm
    int (*ops[3])(int, int) = {add, mul, sub};
    const char *names[] = {"add", "mul", "sub"};

    for (int i = 0; i < 3; i++)
        apply(6, 3, ops[i], names[i]);

    return 0;
}

#include <stdio.h>

int main() {
    int   x   = 42;    // biến int
    int  *p   = &x;    // con trỏ đến int
    int **pp  = &p;    // con trỏ đến con trỏ đến int

    printf("x    = %d\n",  x);
    printf("*p   = %d\n", *p);
    printf("**pp = %d\n", **pp);   // đều là 42

    **pp = 100;   // ghi xuyên qua 2 lớp con trỏ
    printf("x bây giờ = %d\n", x);  // 100
    return 0;
}

#include <stdlib.h>
#include <stdio.h>

int main() {
    int rows = 3, cols = 4;

    // Cấp phát mảng con trỏ (mỗi phần tử là 1 hàng)
    int **mat = (int**) malloc(rows * sizeof(int*));
    for (int i = 0; i < rows; i++)
        mat[i] = (int*) malloc(cols * sizeof(int));

    // Điền và in
    for (int i = 0; i < rows; i++)
        for (int j = 0; j < cols; j++)
            mat[i][j] = i * cols + j;

    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++)
            printf("%3d", mat[i][j]);
        printf("\n");
    }

    // Giải phóng theo thứ tự ngược lại
    for (int i = 0; i < rows; i++)
        free(mat[i]);
    free(mat);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

// Định nghĩa Node
typedef struct Node {
    int data;
    struct Node *next;  // con trỏ đến node tiếp theo
} Node;

// Tạo node mới
Node* new_node(int val) {
    Node* n = (Node*) malloc(sizeof(Node));
    n->data = val;   // n->x tương đương (*n).x
    n->next = NULL;
    return n;
}

// Thêm vào đầu
void push(Node **head, int val) {
    Node* n = new_node(val);
    n->next = *head;
    *head = n;
}

// In danh sách
void print_list(Node* h) {
    while (h) {
        printf("%d → ", h->data);
        h = h->next;
    }
    printf("NULL\n");
}

int main() {
    Node* head = NULL;
    push(&head, 30);
    push(&head, 20);
    push(&head, 10);
    print_list(head);
}

#include <memory>
#include <iostream>
using namespace std;

struct Dog {
    string name;
    Dog(string n) : name(n) { cout << "Dog " << name << " born\n"; }
    ~Dog() { cout << "Dog " << name << " died\n"; }
};

int main() {
    // unique_ptr — tự free khi ra scope
    {
        auto d1 = make_unique<Dog>("Rex");
        cout << "Trong scope\n";
    } // Rex tự động bị xóa ở đây!
    cout << "Sau scope\n";

    // shared_ptr — đếm tham chiếu
    auto d2 = make_shared<Dog>("Buddy");
    {
        auto d3 = d2;   // count = 2
        cout << "Refs: " << d2.use_count() << "\n";  // 2
    } // d3 xóa, count = 1
    cout << "Refs: " << d2.use_count() << "\n";    // 1
    return 0;  // Buddy tự xóa
}

// ✅ 1. Luôn khởi tạo con trỏ
int *p = NULL;

// ✅ 2. Kiểm tra NULL trước khi dùng
if (p != NULL) { *p = 5; }

// ✅ 3. Kiểm tra malloc thành công
p = malloc(sizeof(int));
if (p == NULL) { /* xử lý lỗi */ }

// ✅ 4. Sau free, gán NULL ngay
free(p);
p = NULL;  // tránh dangling pointer

// ✅ 5. Dùng const để bảo vệ dữ liệu read-only
void print(const int *arr, int n) { /* không thể sửa arr */ }

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// ── Student struct ──
typedef struct {
    char name[32];
    float gpa;
} Student;

// ── Comparators (con trỏ hàm) ──
int cmp_by_gpa(const void *a, const void *b) {
    float ga = ((const Student*)a)->gpa;
    float gb = ((const Student*)b)->gpa;
    if (ga < gb) return -1;
    if (ga > gb) return  1;
    return 0;
}

int cmp_by_name(const void *a, const void *b) {
    return strcmp(((const Student*)a)->name,
                  ((const Student*)b)->name);
}

void print_students(Student *s, int n) {
    for (int i = 0; i < n; i++)
        printf("  %-12s GPA: %.1f\n", s[i].name, s[i].gpa);
}

int main() {
    // Cấp phát mảng động
    Student *class = (Student*) malloc(4 * sizeof(Student));
    class[0] = (Student){"Alice",  3.8};
    class[1] = (Student){"Charlie",3.5};
    class[2] = (Student){"Bob",    3.9};
    class[3] = (Student){"Diana",  3.6};

    printf("--- Sắp xếp theo GPA ---\n");
    qsort(class, 4, sizeof(Student), cmp_by_gpa);
    print_students(class, 4);

    printf("--- Sắp xếp theo Tên ---\n");
    qsort(class, 4, sizeof(Student), cmp_by_name);
    print_students(class, 4);

    free(class);
    return 0;
}