引用与指针

int MyClass::* p_member;          // 指向 MyClass 的 int 成员
void (MyClass::* p_method)(int);  // 指向 MyClass 的成员函数

obj.*p_member;      // 通过对象访问
ptr->*p_method(42); // 通过指针访问

#include <iostream>
#include <string>
#include <chrono>

struct LargeData {
    std::string content;
    LargeData() : content(10000, 'A') {}  // 大对象（约 10KB）
};

// 传值：发生完整拷贝
void process_by_value(LargeData data) {
    // data 是副本，修改不影响原对象
    data.content[0] = 'B';
}

// 传指针：拷贝 8 字节地址，但需要判空
void process_by_pointer(LargeData* data) {
    if (data == nullptr) {
        std::cout << "空指针，跳过处理" << std::endl;
        return;
    }
    data->content[0] = 'C';
}

// 传引用：拷贝 8 字节地址，无判空开销，语法简洁
void process_by_reference(LargeData& data) {
    data.content[0] = 'D';
}

// 只读引用：承诺不修改，可接收临时对象
void read_only(const LargeData& data) {
    std::cout << "数据大小: " << data.content.size() << " 字节" << std::endl;
    // data.content[0] = 'X';  // 编译错误：const 引用不可修改
}

int main() {
    LargeData obj;

    // 传递方式对比
    process_by_value(obj);          // 完整拷贝，约 10KB 开销
    process_by_pointer(&obj);       // 拷贝 8 字节，需取地址
    process_by_reference(obj);      // 拷贝 8 字节，直接用对象名

    // const 引用可接受临时对象
    read_only(obj);                 // 可接受左值
    read_only(LargeData());         // 可接受右值（临时对象）

    // 引用 vs 空安全
    LargeData* ptr = nullptr;
    process_by_pointer(ptr);        // 内部判空，安全
    // LargeData& ref = *ptr;      // 未定义行为！引用不能绑定到空

    std::cout << "obj.content[0] = " << obj.content[0]
              << " (原为 'A'，被 reference 版本改为 'D')" << std::endl;

    return 0;
}

#include <iostream>

struct Node {
    int value;
    Node* next;
    Node(int v, Node* n = nullptr) : value(v), next(n) {}
};

// 方式 A：二级指针
void remove_v1(Node** head, int target) {
    Node** indirect = head;
    while (*indirect && (*indirect)->value != target) {
        indirect = &((*indirect)->next);
    }
    if (*indirect) {
        Node* to_delete = *indirect;
        *indirect = (*indirect)->next;
        delete to_delete;
    }
}

// 方式 B：指针引用（更清晰的写法）
void remove_v2(Node*& head, int target) {
    Node** indirect = &head;
    while (*indirect && (*indirect)->value != target) {
        indirect = &((*indirect)->next);
    }
    if (*indirect) {
        Node* to_delete = *indirect;
        *indirect = (*indirect)->next;
        delete to_delete;
    }
}

void print_list(const Node* head) {
    while (head) {
        std::cout << head->value << " -> ";
        head = head->next;
    }
    std::cout << "null" << std::endl;
}

int main() {
    Node* list = new Node(1, new Node(2, new Node(3)));

    std::cout << "原链表: ";
    print_list(list);

    remove_v1(&list, 2);
    std::cout << "删除 2 后 (v1): ";
    print_list(list);

    remove_v2(list, 1);
    std::cout << "删除 1 后 (v2): ";
    print_list(list);

    // 清理
    while (list) {
        Node* tmp = list;
        list = list->next;
        delete tmp;
    }

    return 0;
}

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

struct Student {
    std::string name;
    int id;
    double gpa;

    void print() const {
        std::cout << id << " | " << name << " | GPA " << gpa << std::endl;
    }
};

// 通用排序：使用指向成员数据指针
void sort_by(std::vector<Student>& students,
             double Student::* member,
             bool ascending = true) {
    if (ascending) {
        std::sort(students.begin(), students.end(),
            [member](const Student& a, const Student& b) {
                return a.*member < b.*member;
            });
    } else {
        std::sort(students.begin(), students.end(),
            [member](const Student& a, const Student& b) {
                return a.*member > b.*member;
            });
    }
}

// 使用成员函数指针批量执行操作
void batch_operation(std::vector<Student>& students,
                     void (Student::* op)() const) {
    for (auto& s : students) {
        (s.*op)();
    }
}

int main() {
    std::vector<Student> students = {
        {"张三", 1003, 3.8},
        {"李四", 1001, 3.5},
        {"王五", 1002, 4.0}
    };

    std::cout << "---- 按 GPA 升序 ----" << std::endl;
    sort_by(students, &Student::gpa, true);
    batch_operation(students, &Student::print);

    std::cout << "\n---- 按 ID 降序 ----" << std::endl;
    sort_by(students, &Student::id, false);
    batch_operation(students, &Student::print);

    return 0;
}