指针那些事儿

#include <iostream>

void demonstratePointerEssence() {
    int value = 0x12345678;

    // 同一块内存，不同类型指针的解释
    int* int_ptr = &value;
    char* char_ptr = reinterpret_cast<char*>(&value);
    short* short_ptr = reinterpret_cast<short*>(&value);

    std::cout << "内存地址: " << &value << std::endl;
    std::cout << "int指针解释: " << std::hex << *int_ptr << std::endl;
    std::cout << "char指针解释: " << static_cast<int>(*char_ptr) << std::endl;
    std::cout << "short指针解释: " << *short_ptr << std::endl;

    // 指针算术：类型决定步长
    std::cout << "\n指针算术演示:" << std::endl;
    std::cout << "int_ptr: " << int_ptr << " -> " << (int_ptr + 1) << std::endl;
    std::cout << "char_ptr: " << static_cast<void*>(char_ptr)
              << " -> " << static_cast<void*>(char_ptr + 1) << std::endl;
}

#include <iostream>
#include <memory>

void demonstrateBasicPointers() {
    // 1. 基本对象指针
    int value = 42;
    int* int_ptr = &value;
    std::cout << "基本指针: " << *int_ptr << std::endl;

    // 2. void指针：通用但需要转换
    void* void_ptr = &value;
    // std::cout << *void_ptr;  // 错误：无法解引用void*
    int* converted = static_cast<int*>(void_ptr);
    std::cout << "void指针转换后: " << *converted << std::endl;

    // 3. 空指针：现代C++推荐nullptr
    int* null_ptr = nullptr;  // C++11推荐
    // int* old_null = NULL;  // 不推荐，可能是0

    if (null_ptr == nullptr) {
        std::cout << "安全的空指针检查" << std::endl;
    }
}

#include <iostream>

void demonstrateConstPointers() {
    int value1 = 10, value2 = 20;
    const int const_value = 30;

    // 1. 指向常量的指针（可重新指向，不可修改值）
    const int* ptr_to_const = &value1;
    // *ptr_to_const = 15;  // 错误：不能修改指向的值
    ptr_to_const = &value2;  // 正确：可以重新指向
    std::cout << "指向常量的指针: " << *ptr_to_const << std::endl;

    // 2. 常量指针（不可重新指向，可修改值）
    int* const const_ptr = &value1;
    *const_ptr = 15;         // 正确：可以修改指向的值
    // const_ptr = &value2;  // 错误：不能重新指向
    std::cout << "常量指针: " << *const_ptr << std::endl;

    // 3. 指向常量的常量指针（都不可改变）
    const int* const const_ptr_to_const = &const_value;
    // *const_ptr_to_const = 35;     // 错误：不能修改值
    // const_ptr_to_const = &value1; // 错误：不能重新指向
    std::cout << "常量指针指向常量: " << *const_ptr_to_const << std::endl;
}

#include <iostream>
#include <functional>

// 目标函数
int add(int a, int b) { return a + b; }
int multiply(int a, int b) { return a * b; }

void demonstrateFunctionPointers() {
    // 传统函数指针语法
    int (*operation)(int, int) = add;
    std::cout << "函数指针结果: " << operation(3, 4) << std::endl;

    // 切换函数
    operation = multiply;
    std::cout << "切换后结果: " << operation(3, 4) << std::endl;

    // 现代C++：std::function（更类型安全）
    std::function<int(int, int)> modern_op = add;
    std::cout << "std::function结果: " << modern_op(5, 6) << std::endl;

    // 函数指针数组
    int (*operations[])(int, int) = {add, multiply};
    for (size_t i = 0; i < 2; ++i) {
        std::cout << "操作 " << i << ": " << operations[i](2, 3) << std::endl;
    }

    // Lambda表达式
    auto lambda_op = [](int a, int b) { return a - b; };
    std::function<int(int, int)> func_lambda = lambda_op;
    std::cout << "Lambda结果: " << func_lambda(10, 3) << std::endl;
}

#include <iostream>

class MyClass {
public:
    int data = 42;
    static int static_data;

    void display() const {
        std::cout << "MyClass数据: " << data << std::endl;
    }

    void setData(int value) {
        data = value;
    }
};

int MyClass::static_data = 100;

void demonstrateMemberPointers() {
    MyClass obj;

    // 成员变量指针
    int MyClass::*member_ptr = &MyClass::data;
    std::cout << "通过成员指针访问: " << obj.*member_ptr << std::endl;

    // 修改成员变量
    obj.*member_ptr = 99;
    std::cout << "修改后: " << obj.*member_ptr << std::endl;

    // 成员函数指针
    void (MyClass::*func_ptr)() const = &MyClass::display;
    (obj.*func_ptr)();

    void (MyClass::*setter_ptr)(int) = &MyClass::setData;
    (obj.*setter_ptr)(77);
    obj.display();

    // 静态成员不需要成员指针
    int* static_ptr = &MyClass::static_data;
    std::cout << "静态成员: " << *static_ptr << std::endl;
}

#include <iostream>
#include <type_traits>

void demonstrateArrayEssence() {
    int arr[5] = {1, 2, 3, 4, 5};

    std::cout << "=== 数组本质分析 ===" << std::endl;
    std::cout << "数组名: " << arr << std::endl;
    std::cout << "首元素地址: " << &arr[0] << std::endl;
    std::cout << "数组地址: " << &arr << std::endl;

    // 数组名在不同上下文中的含义
    std::cout << "\n=== 数组名的不同含义 ===" << std::endl;
    std::cout << "sizeof(arr): " << sizeof(arr) << " 字节" << std::endl;
    std::cout << "sizeof(&arr[0]): " << sizeof(&arr[0]) << " 字节" << std::endl;

    // 数组到指针的隐式转换
    int* ptr = arr;  // 数组名隐式转换为指针
    std::cout << "转换后的指针: " << ptr << std::endl;

    // 指针算术
    std::cout << "\n=== 指针算术 ===" << std::endl;
    for (int i = 0; i < 5; ++i) {
        std::cout << "arr[" << i << "] = " << *(arr + i)
                  << " (地址: " << (arr + i) << ")" << std::endl;
    }

    // 数组类型推导
    std::cout << "\n=== 类型推导 ===" << std::endl;
    std::cout << "arr是数组: " << std::is_array_v<decltype(arr)> << std::endl;
    std::cout << "ptr是指针: " << std::is_pointer_v<decltype(ptr)> << std::endl;
}

#include <iostream>

// 函数重载展示数组退化
void processArray(int arr[]) {  // 等价于 int* arr
    std::cout << "函数内sizeof(arr): " << sizeof(arr) << " 字节" << std::endl;
    std::cout << "这实际上是指针大小" << std::endl;
}

void processArray(int arr[10]) {  // 仍然等价于 int* arr
    std::cout << "指定大小也无效，仍是指针" << std::endl;
}

// 阻止数组退化的方法
template<size_t N>
void processArrayTemplate(int (&arr)[N]) {
    std::cout << "模板函数保持数组类型，大小: " << N << std::endl;
    std::cout << "sizeof(arr): " << sizeof(arr) << " 字节" << std::endl;
}

// C++17 std::array 替代方案
#include <array>
void processStdArray(const std::array<int, 5>& arr) {
    std::cout << "std::array大小: " << arr.size() << std::endl;
    std::cout << "类型安全且不退化" << std::endl;
}

void demonstrateArrayDecay() {
    int arr[5] = {1, 2, 3, 4, 5};

    std::cout << "=== 数组退化演示 ===" << std::endl;
    std::cout << "原数组sizeof: " << sizeof(arr) << " 字节" << std::endl;

    processArray(arr);  // 数组退化为指针

    std::cout << "\n=== 阻止数组退化 ===" << std::endl;
    processArrayTemplate(arr);  // 保持数组类型

    std::cout << "\n=== 现代C++解决方案 ===" << std::endl;
    std::array<int, 5> modern_arr = {1, 2, 3, 4, 5};
    processStdArray(modern_arr);
}

#include <iostream>
#include <iomanip>

void demonstrateMultiDimensionalArrays() {
    // 二维数组定义
    int matrix[3][4] = {
        {1,  2,  3,  4},
        {5,  6,  7,  8},
        {9, 10, 11, 12}
    };

    std::cout << "=== 二维数组内存布局 ===" << std::endl;
    std::cout << "数组地址: " << matrix << std::endl;
    std::cout << "第一行地址: " << matrix[0] << std::endl;
    std::cout << "第二行地址: " << matrix[1] << std::endl;

    // 逐个元素的地址分析
    std::cout << "\n=== 元素地址分析 ===" << std::endl;
    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 4; ++j) {
            std::cout << "matrix[" << i << "][" << j << "] = "
                      << std::setw(2) << matrix[i][j]
                      << " (地址: " << &matrix[i][j] << ")" << std::endl;
        }
    }

    // 内存连续性验证
    std::cout << "\n=== 内存连续性验证 ===" << std::endl;
    int* flat_ptr = &matrix[0][0];
    for (int i = 0; i < 12; ++i) {
        std::cout << "flat_ptr[" << i << "] = " << flat_ptr[i] << std::endl;
    }

    // 行主序存储
    std::cout << "\n=== 行主序存储计算 ===" << std::endl;
    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 4; ++j) {
            int linear_index = i * 4 + j;
            std::cout << "matrix[" << i << "][" << j << "] = "
                      << "flat[" << linear_index << "] = "
                      << flat_ptr[linear_index] << std::endl;
        }
    }
}

#include <iostream>
#include <memory>
#include <vector>

// 场景1：函数需要修改指针本身
bool allocateArray(int** arr, int size) {
    *arr = new(std::nothrow) int[size];
    if (*arr == nullptr) {
        return false;
    }

    // 初始化数组
    for (int i = 0; i < size; ++i) {
        (*arr)[i] = i * i;
    }
    return true;
}

// 场景2：动态二维数组
int** create2DArray(int rows, int cols) {
    int** matrix = new int*[rows];
    for (int i = 0; i < rows; ++i) {
        matrix[i] = new int[cols];
        for (int j = 0; j < cols; ++j) {
            matrix[i][j] = i * cols + j;
        }
    }
    return matrix;
}

void destroy2DArray(int** matrix, int rows) {
    for (int i = 0; i < rows; ++i) {
        delete[] matrix[i];
    }
    delete[] matrix;
}

// 现代C++替代方案
class Matrix {
private:
    std::vector<std::vector<int>> data;

public:
    Matrix(int rows, int cols) : data(rows, std::vector<int>(cols)) {
        for (int i = 0; i < rows; ++i) {
            for (int j = 0; j < cols; ++j) {
                data[i][j] = i * cols + j;
            }
        }
    }

    int& operator()(int row, int col) {
        return data[row][col];
    }

    const int& operator()(int row, int col) const {
        return data[row][col];
    }

    void print() const {
        for (const auto& row : data) {
            for (const auto& val : row) {
                std::cout << val << " ";
            }
            std::cout << std::endl;
        }
    }
};

void demonstrateMultiLevelPointers() {
    std::cout << "=== 多级指针应用演示 ===" << std::endl;

    // 场景1：函数修改指针
    int* array = nullptr;
    if (allocateArray(&array, 5)) {
        std::cout << "动态分配成功: ";
        for (int i = 0; i < 5; ++i) {
            std::cout << array[i] << " ";
        }
        std::cout << std::endl;
        delete[] array;
    }

    // 场景2：动态二维数组
    std::cout << "\n=== 传统动态二维数组 ===" << std::endl;
    int** matrix = create2DArray(3, 4);
    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 4; ++j) {
            std::cout << matrix[i][j] << " ";
        }
        std::cout << std::endl;
    }
    destroy2DArray(matrix, 3);

    // 现代C++方案
    std::cout << "\n=== 现代C++矩阵类 ===" << std::endl;
    Matrix modern_matrix(3, 4);
    modern_matrix.print();
}

#include <iostream>
#include <memory>
#include <vector>

// 错误的内存管理示例
void badMemoryManagement() {
    std::cout << "=== 错误的内存管理 ===" << std::endl;

    int* ptr = new int(42);
    // 忘记 delete ptr;  // 内存泄漏

    int* arr = new int[10];
    // delete arr;  // 错误：应该是 delete[]

    int** matrix = new int*[5];
    for (int i = 0; i < 5; ++i) {
        matrix[i] = new int[10];
    }
    // 忘记释放内部数组
    delete[] matrix;  // 只释放了指针数组，内存泄漏
}

// 正确的内存管理
void goodMemoryManagement() {
    std::cout << "=== 正确的内存管理 ===" << std::endl;

    // 1. 使用智能指针
    {
        auto ptr = std::make_unique<int>(42);
        std::cout << "智能指针自动管理: " << *ptr << std::endl;
        // 自动释放，无需手动delete
    }

    // 2. 使用智能指针数组
    {
        auto arr = std::make_unique<int[]>(10);
        for (int i = 0; i < 10; ++i) {
            arr[i] = i;
        }
        std::cout << "智能指针数组: ";
        for (int i = 0; i < 10; ++i) {
            std::cout << arr[i] << " ";
        }
        std::cout << std::endl;
        // 自动释放
    }

    // 3. 使用容器代替原始指针
    {
        std::vector<int> vec(10);
        std::iota(vec.begin(), vec.end(), 0);
        std::cout << "vector容器: ";
        for (const auto& val : vec) {
            std::cout << val << " ";
        }
        std::cout << std::endl;
        // 自动管理内存
    }

    // 4. 二维数据使用vector<vector<>>或一维数组模拟
    {
        // 方案一：vector<vector<>>
        std::vector<std::vector<int>> matrix2d(3, std::vector<int>(4));

        // 方案二：一维数组模拟二维（更高效）
        std::vector<int> matrix1d(3 * 4);
        auto access = [&](int row, int col) -> int& {
            return matrix1d[row * 4 + col];
        };

        access(1, 2) = 99;
        std::cout << "一维模拟二维: " << access(1, 2) << std::endl;
    }
}

// RAII包装器示例
template<typename T>
class AutoArray {
private:
    T* data;
    size_t size;

public:
    explicit AutoArray(size_t n) : size(n) {
        data = new T[n]();  // 零初始化
    }

    ~AutoArray() {
        delete[] data;
    }

    // 禁用拷贝，启用移动
    AutoArray(const AutoArray&) = delete;
    AutoArray& operator=(const AutoArray&) = delete;

    AutoArray(AutoArray&& other) noexcept
        : data(other.data), size(other.size) {
        other.data = nullptr;
        other.size = 0;
    }

    AutoArray& operator=(AutoArray&& other) noexcept {
        if (this != &other) {
            delete[] data;
            data = other.data;
            size = other.size;
            other.data = nullptr;
            other.size = 0;
        }
        return *this;
    }

    T& operator[](size_t index) {
        return data[index];
    }

    const T& operator[](size_t index) const {
        return data[index];
    }

    size_t getSize() const { return size; }
};

void demonstrateRAII() {
    std::cout << "\n=== RAII包装器演示 ===" << std::endl;

    AutoArray<int> arr(10);
    for (size_t i = 0; i < arr.getSize(); ++i) {
        arr[i] = i * i;
    }

    std::cout << "RAII数组: ";
    for (size_t i = 0; i < arr.getSize(); ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;
    // 自动释放
}

#include <iostream>
#include <memory>
#include <vector>

void demonstrateCommonPointerErrors() {
    std::cout << "=== 常见指针错误及预防 ===" << std::endl;

    // 1. 悬挂指针
    {
        int* dangling_ptr;
        {
            int local_var = 42;
            dangling_ptr = &local_var;
        }  // local_var 生命周期结束
        // std::cout << *dangling_ptr;  // 未定义行为

        // 预防：使用智能指针或确保生命周期
        auto safe_ptr = std::make_shared<int>(42);
        // safe_ptr 自动管理生命周期
    }

    // 2. 双重释放
    {
        // int* ptr = new int(42);
        // delete ptr;
        // delete ptr;  // 错误：双重释放

        // 预防：使用智能指针或手动置nullptr
        int* ptr = new int(42);
        delete ptr;
        ptr = nullptr;  // 防止误用
        delete ptr;     // 对nullptr执行delete是安全的
    }

    // 3. 内存泄漏
    {
        // 错误示例
        // int* ptr = new int(42);
        // if (some_condition) return;  // 忘记delete，内存泄漏

        // 正确做法：使用RAII
        auto ptr = std::make_unique<int>(42);
        // 即使提前返回，也会自动释放
    }

    // 4. 缓冲区溢出
    {
        // 错误示例
        // int arr[5];
        // arr[10] = 100;  // 缓冲区溢出

        // 预防：使用std::array或std::vector
        std::array<int, 5> safe_arr{};
        try {
            safe_arr.at(10) = 100;  // 抛出异常而不是未定义行为
        } catch (const std::out_of_range& e) {
            std::cout << "捕获越界访问: " << e.what() << std::endl;
        }
    }
}

#include <iostream>
#include <memory>
#include <vector>
#include <algorithm>

// 智能指针的正确使用
void demonstrateSmartPointers() {
    std::cout << "=== 智能指针最佳实践 ===" << std::endl;

    // 1. unique_ptr：独占所有权
    {
        auto ptr = std::make_unique<int>(42);
        std::cout << "unique_ptr: " << *ptr << std::endl;

        // 转移所有权
        auto ptr2 = std::move(ptr);
        // ptr 现在为空，ptr2 拥有资源
        std::cout << "转移后: " << (ptr ? "有效" : "空") << std::endl;
        std::cout << "新指针: " << *ptr2 << std::endl;
    }

    // 2. shared_ptr：共享所有权
    {
        auto ptr1 = std::make_shared<int>(100);
        std::cout << "引用计数: " << ptr1.use_count() << std::endl;

        {
            auto ptr2 = ptr1;  // 拷贝，增加引用计数
            std::cout << "共享后引用计数: " << ptr1.use_count() << std::endl;
        }  // ptr2 销毁，引用计数减少

        std::cout << "减少后引用计数: " << ptr1.use_count() << std::endl;
    }

    // 3. weak_ptr：解决循环引用
    {
        struct Node {
            std::shared_ptr<Node> next;
            std::weak_ptr<Node> parent;  // 使用weak_ptr避免循环引用
            int value;

            Node(int v) : value(v) {}
            ~Node() { std::cout << "Node " << value << " 析构" << std::endl; }
        };

        auto node1 = std::make_shared<Node>(1);
        auto node2 = std::make_shared<Node>(2);

        node1->next = node2;
        node2->parent = node1;  // weak_ptr，不增加引用计数

        std::cout << "node1引用计数: " << node1.use_count() << std::endl;
        std::cout << "node2引用计数: " << node2.use_count() << std::endl;
    }  // 正确析构，无内存泄漏
}

// 传统C风格 -> 现代C++风格
// int* arr = new int[size];              -> std::vector<int> arr(size);
// int** matrix = new int*[rows];         -> std::vector<std::vector<int>> matrix;
// char* str = new char[100];             -> std::string str;
// void* generic_ptr;                     -> std::any 或模板
// function_ptr();                        -> std::function<> 或lambda