指针与引用 ⭐⭐

// ============ 指针声明的三种书写风格 ============
// 它们在语义上完全等价，只是代码风格不同
 
int* p1;    // 风格一：星号靠近类型 (推荐，C++ 社区主流风格)
int *p2;    // 风格二：星号靠近变量名 (C 语言传统风格)
int * p3;   // 风格三：星号两边都有空格 (较少见)

int* p1, p2;   // 注意！p1 是 int*（指针），但 p2 只是一个普通 int！

int *p1, *p2;   // 正确：p1 和 p2 都是 int* 类型
// 或者更好的做法 —— 分开写（最推荐）
int* p1;        // p1 是 int*
int* p2;        // p2 是 int*

int* pi;        // 指向 int 的指针
double* pd;     // 指向 double 的指针
char* pc;       // 指向 char 的指针
std::string* ps;// 指向 std::string 对象的指针

#include <iostream>
 
int main() {
    int score = 95;               // 声明一个 int 变量，值为 95
 
    std::cout << "score 的值: "   // 输出变量的值
              << score             // 结果: 95
              << std::endl;
 
    std::cout << "score 的地址: " // 输出变量的内存地址
              << &score            // 结果类似: 0x7ffee3b4a8bc (每次运行可能不同)
              << std::endl;
 
    return 0;
}

int score = 95;       // 普通 int 变量
int* ptr = &score;    // ptr 现在存储了 score 的地址，即 ptr "指向" score

// ===== 内存模型 (概念示意，非真实地址) =====
//
//  变量名     地址          值
//  ─────────────────────────────────
//  score      0x1000        95          ← int, 占 4 字节
//  ptr        0x1008        0x1000      ← int*, 存的是 score 的地址
//
//  ptr ──────────────► score
//  (值=0x1000)           (值=95)

int a = 10;
int* p1 = &a;        // ✅ 合法：a 是一个有地址的变量(左值)
 
int* p2 = &42;       // ❌ 编译错误！42 是字面量(右值)，没有可取的内存地址
int* p3 = &(a + 1);  // ❌ 编译错误！(a + 1) 是临时计算结果(右值)
 
int arr[3] = {1,2,3};
int* p4 = &arr[0];   // ✅ 合法：数组元素是左值

#include <iostream>
 
int main() {
    int health = 100;            // 声明变量 health，初始化为 100
    int* ptr = &health;          // 指针 ptr 指向 health
 
    // -------- 读取：通过指针间接访问变量的值 --------
    std::cout << "health 的值: "
              << health          // 直接访问：100
              << std::endl;
 
    std::cout << "通过指针读取: "
              << *ptr            // 解引用访问：100（与上面结果相同）
              << std::endl;
 
    // -------- 修改：通过指针间接修改变量的值 --------
    *ptr = 75;                   // 通过解引用，将 ptr 指向的内存（即 health）改为 75
 
    std::cout << "修改后 health: "
              << health          // 输出: 75（health 的值确实被改变了！）
              << std::endl;
 
    // -------- 验证互逆关系 --------
    std::cout << std::boolalpha  // 让 bool 输出 true/false 而不是 1/0
              << "(*(&health) == health): "
              << (*(&health) == health)  // 输出: true
              << std::endl;
 
    return 0;                    // 程序正常结束
}

int val = 50;        // 普通 int 变量
int* ptr = &val;     // 这里的 * 是「声明」中的类型修饰符，表示 ptr 是 int* 类型
*ptr = 99;           // 这里的 * 是「解引用」运算符，通过 ptr 修改 val 的值为 99

int* p;              // ⚠️ 未初始化！p 的值是随机的垃圾地址
*p = 42;             // 💥 未定义行为 (Undefined Behavior)！
                     // 可能崩溃，可能"看起来正常"，可能破坏其他数据

// ✅ 规则 1：声明指针时，要么立即指向有效变量，要么初始化为 nullptr
int* p1 = nullptr;   // 明确表示"当前不指向任何对象"
 
// ✅ 规则 2：使用前检查是否为空
if (p1 != nullptr) { // 或者简写为 if (p1)
    *p1 = 42;        // 只有确认非空才解引用
}
 
// ✅ 规则 3：指针不再使用时，置为 nullptr
p1 = nullptr;        // 防止成为悬空指针 (dangling pointer)

#include <iostream>
 
int main() {
    // ===== Step 1: 声明变量 =====
    int x = 10;                  // 声明 int 变量 x，值为 10
    int y = 20;                  // 声明 int 变量 y，值为 20
 
    // ===== Step 2: 声明指针并初始化 =====
    int* ptr = &x;               // ptr 指向 x
 
    // ===== Step 3: 通过指针读取 =====
    std::cout << "ptr 指向的值: " 
              << *ptr             // 输出: 10 (即 x 的值)
              << std::endl;
 
    // ===== Step 4: 通过指针修改 =====
    *ptr = 100;                  // 将 x 的值从 10 改为 100
    std::cout << "x = " << x    // 输出: x = 100
              << std::endl;
 
    // ===== Step 5: 指针重新指向另一个变量 =====
    ptr = &y;                    // ptr 不再指向 x，转而指向 y
    *ptr = 200;                  // 将 y 的值从 20 改为 200
    std::cout << "y = " << y    // 输出: y = 200
              << std::endl;
 
    // ===== Step 6: 验证地址信息 =====
    std::cout << "x 的地址: " << &x << std::endl;   // 输出 x 的地址
    std::cout << "y 的地址: " << &y << std::endl;   // 输出 y 的地址
    std::cout << "ptr 的值: " << ptr << std::endl;   // 等于 &y
    std::cout << "ptr 自身地址: " << &ptr << std::endl; // ptr 自己的地址
 
    return 0;
}

#include <iostream>
 
int main() {
    // 不同类型的指针
    int* pi    = nullptr;        // 指向 int
    double* pd = nullptr;        // 指向 double
    char* pc   = nullptr;        // 指向 char
 
    // 在 64 位系统上，所有指针大小都是 8 字节
    std::cout << "sizeof(int*):    " << sizeof(pi) << std::endl;  // 8
    std::cout << "sizeof(double*): " << sizeof(pd) << std::endl;  // 8
    std::cout << "sizeof(char*):   " << sizeof(pc) << std::endl;  // 8
 
    // 但它们指向的数据大小不同！
    std::cout << "sizeof(int):     " << sizeof(int) << std::endl;    // 4
    std::cout << "sizeof(double):  " << sizeof(double) << std::endl; // 8
    std::cout << "sizeof(char):    " << sizeof(char) << std::endl;   // 1
 
    return 0;
}

#include <iostream>
int main() {
    int a = 5;
    int b = 10;
    int* p = &a;
    *p = 20;
    p = &b;
    *p = *p + a;
    std::cout << a << " " << b << std::endl;
    return 0;
}

#include <iostream>
using namespace std;
 
int main() {
    int arr[5] = {10, 20, 30, 40, 50};   // 声明一个含5个int元素的数组
    int* ptr = arr;                        // ptr 指向数组首元素 arr[0]，等价于 &arr[0]
 
    cout << "ptr 的地址: " << ptr << endl;         // 输出 ptr 当前指向的地址
    cout << "ptr 的值:   " << *ptr << endl;        // 解引用，输出 10
 
    ptr = ptr + 1;  // 指针前进"1步"，实际地址偏移 1 * sizeof(int) = 4 字节
    cout << "ptr+1 的地址: " << ptr << endl;       // 地址比原来大了 4
    cout << "ptr+1 的值:   " << *ptr << endl;      // 解引用，输出 20
 
    ptr = ptr + 3;  // 再前进3步，偏移 3 * sizeof(int) = 12 字节
    cout << "ptr+3 的地址: " << ptr << endl;       // 地址又增加了 12
    cout << "ptr+3 的值:   " << *ptr << endl;      // 解引用，输出 50（arr[4]）
 
    return 0;
}

#include <iostream>
using namespace std;
 
int main() {
    double data[4] = {1.1, 2.2, 3.3, 4.4};  // double 数组
    double* dp = &data[3];                     // dp 指向最后一个元素 data[3]
 
    cout << *dp << endl;      // 输出 4.4
    dp = dp - 2;              // 回退2步，偏移 2 * sizeof(double) = 16 字节
    cout << *dp << endl;      // 输出 2.2，即 data[1]
 
    return 0;
}

#include <iostream>
using namespace std;
 
int main() {
    int arr[4] = {100, 200, 300, 400};
    int* p = arr;               // p 指向 arr[0]
 
    // 场景1: *p++  →  先取 *p 的值，再 p++
    cout << *p++ << endl;       // 输出 100，之后 p 指向 arr[1]
 
    // 场景2: *++p  →  先 ++p，再取 *p 的值
    cout << *++p << endl;       // p 先移到 arr[2]，输出 300
 
    // 场景3: (*p)++  →  取 *p 的值后，将该值自增
    cout << (*p)++ << endl;     // 输出 300（arr[2]的当前值），之后 arr[2] 变为 301
    cout << *p << endl;         // 验证：输出 301，p 仍指向 arr[2]
 
    return 0;
}

#include <iostream>
using namespace std;
 
int main() {
    int arr[6] = {0, 10, 20, 30, 40, 50};
 
    int* p1 = &arr[1];      // p1 指向 arr[1]
    int* p2 = &arr[5];      // p2 指向 arr[5]
 
    // 指针相减：结果是元素间距，而非字节距离
    ptrdiff_t diff = p2 - p1;   // diff = 4（相隔4个int元素）
    cout << "p2 - p1 = " << diff << endl;   // 输出 4
 
    // 反过来减也可以，结果为负数
    cout << "p1 - p2 = " << (p1 - p2) << endl;  // 输出 -4
 
    return 0;
}

int* p1 = &arr[0];
int* p2 = &arr[3];
// auto result = p1 + p2;  // ❌ 编译错误！指针不能相加

#include <iostream>
using namespace std;
 
int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    int* begin = arr;           // 指向首元素
    int* end   = arr + 5;      // 指向数组"末尾之后"（past-the-end）
 
    // 用指针比较来判断是否遍历完毕
    int* cur = begin;           // cur 从首元素开始
    while (cur < end) {         // 当 cur 还没到 end 时继续
        cout << *cur << " ";    // 输出当前元素
        cur++;                  // 指针后移一步
    }
    // 输出：1 2 3 4 5
 
    return 0;
}

#include <iostream>
using namespace std;
 
int main() {
    int arr[5] = {10, 20, 30, 40, 50};
 
    // 传统的下标遍历
    for (int i = 0; i < 5; i++) {
        cout << arr[i] << " ";    // arr[i] 等价于 *(arr + i)
    }
    cout << endl;
    return 0;
}

#include <iostream>
using namespace std;
 
int main() {
    int arr[5] = {10, 20, 30, 40, 50};
    int* ptr = arr;               // ptr 指向数组首元素
 
    // 指针递增遍历
    for (int i = 0; i < 5; i++) {
        cout << *ptr << " ";      // 解引用取当前值
        ptr++;                    // 指针后移一步（偏移 sizeof(int) 字节）
    }
    cout << endl;
    return 0;
}

#include <iostream>
using namespace std;
 
int main() {
    int arr[5] = {10, 20, 30, 40, 50};
    int* begin = arr;             // 指向第一个元素
    int* end   = arr + 5;        // 指向最后一个元素的"下一个位置"（past-the-end）
 
    // begin/end 风格遍历，与 STL 迭代器写法一致
    for (int* p = begin; p != end; p++) {
        cout << *p << " ";        // 解引用当前指针
    }
    cout << endl;
    return 0;
}

#include <iostream>
using namespace std;
 
int main() {
    int arr[5] = {10, 20, 30, 40, 50};
    int* ptr = arr;               // ptr 始终指向首元素
 
    // 偏移法遍历
    for (int i = 0; i < 5; i++) {
        cout << *(ptr + i) << " ";  // ptr不动，每次通过偏移量 i 访问
    }
    cout << endl;
    return 0;
}

#include <iostream>
using namespace std;
 
// 使用指针反转数组
void reverseArray(int* begin, int* end) {
    // end 传入时指向 past-the-end，先回退一步指向最后一个元素
    end--;
 
    // 当左指针在右指针左边时，继续交换
    while (begin < end) {
        // 交换 begin 和 end 所指向的值
        int temp = *begin;        // 暂存左侧值
        *begin = *end;            // 右侧值赋给左侧
        *end = temp;              // 暂存值赋给右侧
 
        begin++;                  // 左指针右移一步
        end--;                    // 右指针左移一步
    }
}
 
int main() {
    int arr[6] = {1, 2, 3, 4, 5, 6};
 
    cout << "反转前: ";
    for (int* p = arr; p != arr + 6; p++) {   // 用 begin/end 风格输出
        cout << *p << " ";
    }
    cout << endl;
 
    reverseArray(arr, arr + 6);   // 传入 [begin, end) 左闭右开区间
 
    cout << "反转后: ";
    for (int* p = arr; p != arr + 6; p++) {   // 再次遍历输出
        cout << *p << " ";
    }
    cout << endl;
 
    return 0;
}
// 输出:
// 反转前: 1 2 3 4 5 6
// 反转后: 6 5 4 3 2 1

// 初始状态：
// begin                        end (回退后)
//   ↓                            ↓
// [ 1 ]  [ 2 ]  [ 3 ]  [ 4 ]  [ 5 ]  [ 6 ]
//
// 第1轮交换后 (swap 1 和 6)，begin++, end--：
//         begin          end
//           ↓              ↓
// [ 6 ]  [ 2 ]  [ 3 ]  [ 4 ]  [ 5 ]  [ 1 ]
//
// 第2轮交换后 (swap 2 和 5)，begin++, end--：
//                begin  end
//                  ↓      ↓
// [ 6 ]  [ 5 ]  [ 3 ]  [ 4 ]  [ 2 ]  [ 1 ]
//
// 第3轮交换后 (swap 3 和 4)，begin++, end--：
//                 end  begin    ← begin > end, 循环终止!
//                  ↓     ↓
// [ 6 ]  [ 5 ]  [ 4 ]  [ 3 ]  [ 2 ]  [ 1 ]

#include <iostream>
using namespace std;
 
int main() {
    int arr[3] = {10, 20, 30};
    int* p = arr + 3;     // ✅ 指向 past-the-end 是合法的（但不可解引用）
 
    // cout << *p << endl; // ❌ UB! 解引用 past-the-end 指针
 
    int* q = arr + 10;    // ❌ UB! 指针偏移远超数组范围
    int* r = arr - 1;     // ❌ UB! 指针跑到数组起始位置之前
 
    return 0;
}

int arr[5] = {2, 4, 6, 8, 10};
int* p = arr + 4;
cout << *p << " ";
p = p - 3;
cout << *p << " ";
cout << *(p + 2) << " ";
cout << p[1] << endl;

// ❌ 危险：未初始化的指针（野指针）
int* p;            // p 的值是随机的垃圾地址
// *p = 42;        // 未定义行为！可能崩溃
 
// ✅ 安全：初始化为空指针
int* q = nullptr;  // q 明确表示"不指向任何对象"
if (q != nullptr) {
    *q = 42;       // 只有非空时才解引用，安全
}

// --- C 语言中的典型定义 ---
#define NULL ((void*)0)   // 将整数 0 强转为 void* 类型
 
// --- C++ 中的典型定义（不同编译器略有差异）---
#define NULL 0            // 直接是整数字面量 0
// 或者
#define NULL 0L           // long 类型的 0

#include <iostream>
 
// 重载 1：接收整数
void process(int value) {
    std::cout << "process(int): " << value << std::endl;
}
 
// 重载 2：接收指针
void process(int* ptr) {
    std::cout << "process(int*): " << ptr << std::endl;
}
 
int main() {
    process(NULL);      // ⚠️ 调用的是 process(int)，而非 process(int*)！
                        // 因为 NULL == 0，0 是 int 字面量
                        // 编译器优先匹配 process(int)
    return 0;
}

#include <iostream>
#include <cstddef>    // std::nullptr_t 定义在此
 
void process(int value) {
    std::cout << "process(int): " << value << std::endl;
}
 
void process(int* ptr) {
    std::cout << "process(int*): " << ptr << std::endl;
}
 
int main() {
    process(nullptr);   // ✅ 明确调用 process(int*)
                        // nullptr 的类型是 std::nullptr_t
                        // 它可以隐式转换为 int*，但不能转为 int
                        // 因此无歧义地匹配 process(int*)
 
    // 验证 nullptr 的类型
    std::nullptr_t np = nullptr;  // np 的类型就是 std::nullptr_t
    int* p = np;                  // ✅ 合法：nullptr_t 可隐式转为 int*
    // int n = np;                // ❌ 编译错误：nullptr_t 不能转为 int
 
    return 0;
}

#include <iostream>
#include <typeinfo>   // 用于 typeid
 
template<typename T>
void check(T arg) {
    // 打印模板推导出的类型名称
    std::cout << "T = " << typeid(T).name() << std::endl;
}
 
int main() {
    check(0);        // T 被推导为 int        → 输出类似 "i"
    check(NULL);     // T 被推导为 int 或 long → 输出类似 "i" 或 "l"
                     // 完全丢失了"指针"的语义！
 
    check(nullptr);  // T 被推导为 std::nullptr_t → 输出类似 "Dn"
                     // 保留了空指针的类型信息 ✅
 
    return 0;
}

int* p = nullptr;   // p 是空指针
// *p = 10;         // ❌ 未定义行为！不要这样做
 
// 正确做法：解引用前必须检查
if (p != nullptr) { // 先判空
    *p = 10;        // 确认非空后才安全
}

// === 空指针 vs 有效指针 的内存模型 ===
 
//  变量 p (空指针)
//  ┌──────────────────┐
//  │  p: 0x00000000   │──────→  ╳ (不指向任何地址)
//  │  (nullptr)       │         解引用 = 未定义行为!
//  └──────────────────┘
//
//  变量 q (有效指针)
//  ┌──────────────────┐         ┌──────────┐
//  │  q: 0x7FFE1234   │──────→  │  42      │  (int 变量 x)
//  │  (合法地址)       │         │ 地址:    │
//  └──────────────────┘         │ 0x7FFE1234│
//                               └──────────┘

// ❌ 旧风格（C++98）
int* p1 = NULL;
int* p2 = 0;
 
// ✅ 现代 C++（C++11 及以后）
int* p3 = nullptr;       // 明确、类型安全

int* ptr = getSomePointer();  // 可能返回 nullptr
 
// 写法 1：显式比较（推荐，意图清晰）
if (ptr != nullptr) {
    // 使用 *ptr
}
 
// 写法 2：利用隐式布尔转换（简洁，C++ 社区常见）
if (ptr) {                     // 非空指针在 bool 上下文中为 true
    // 使用 *ptr
}
 
// 写法 3：取反判空
if (!ptr) {                    // 空指针在 bool 上下文中为 false
    std::cerr << "Error: null pointer!" << std::endl;
    return;
}

int* data = new int(100);     // 动态分配内存
// ... 使用 data ...
delete data;                   // 释放内存
data = nullptr;                // ✅ 立即置空，避免悬垂指针（Dangling Pointer）
 
// 后续代码即使误操作也能安全检查
if (data != nullptr) {
    *data = 200;               // 不会执行，因为 data 已是 nullptr
}

#include <iostream>
 
// 在数组中查找目标值，找到返回其地址，否则返回 nullptr
int* findValue(int arr[], int size, int target) {
    for (int i = 0; i < size; ++i) {  // 遍历数组每个元素
        if (arr[i] == target) {        // 找到目标
            return &arr[i];            // 返回该元素的地址
        }
    }
    return nullptr;                    // 未找到，返回空指针
}
 
int main() {
    int nums[] = {10, 20, 30, 40, 50};          // 测试数组
    int* result = findValue(nums, 5, 30);        // 查找 30
 
    if (result != nullptr) {                      // 判空检查
        std::cout << "Found: " << *result << std::endl;  // 输出: Found: 30
    } else {
        std::cout << "Not found." << std::endl;
    }
 
    result = findValue(nums, 5, 99);             // 查找不存在的 99
    if (result) {                                 // 隐式判空
        std::cout << "Found: " << *result << std::endl;
    } else {
        std::cout << "Not found." << std::endl;  // 输出: Not found.
    }
 
    return 0;
}

#include <memory>
 
std::shared_ptr<int> sp;             // 默认构造，内部为空
if (sp == nullptr) {                  // ✅ 合法比较
    sp = std::make_shared<int>(42);   // 分配并指向 42
}
 
std::unique_ptr<int> up = nullptr;    // ✅ 直接用 nullptr 初始化
up = std::make_unique<int>(100);      // 分配并指向 100
up = nullptr;                         // ✅ 释放资源并重置为空

#include <iostream>
 
void handle(int* ptr) {
    std::cout << "Handling a valid pointer" << std::endl;
}
 
void handle(std::nullptr_t) {                   // 只匹配 nullptr
    std::cout << "Handling nullptr (no-op)" << std::endl;
}
 
int main() {
    int x = 10;
    handle(&x);        // 调用 handle(int*)        → "Handling a valid pointer"
    handle(nullptr);   // 调用 handle(nullptr_t)   → "Handling nullptr (no-op)"
    return 0;
}

#include <iostream>
 
void foo(int)         { std::cout << "A"; }
void foo(int*)        { std::cout << "B"; }
void foo(bool)        { std::cout << "C"; }
 
int main() {
    foo(NULL);
    foo(nullptr);
    foo(false);
    return 0;
}

#include <iostream>
using namespace std;
 
int main() {
    int arr[5] = {10, 20, 30, 40, 50}; // 声明一个含 5 个 int 的数组
 
    // arr 在表达式中 decay 为 int* 类型，指向首元素 arr[0]
    int* p = arr;                       // 等价于 int* p = &arr[0];
 
    cout << *p << endl;                 // 输出 10，解引用得到首元素的值
    cout << p << endl;                  // 输出首元素的内存地址，如 0x7ffd1234
    cout << arr << endl;               // 输出同样的地址，验证 arr decay 为 &arr[0]
 
    return 0;
}

#include <iostream>
using namespace std;
 
int main() {
    int arr[5] = {10, 20, 30, 40, 50}; // 5 个 int，共 5 * 4 = 20 字节
 
    int* p = arr;                       // p 是指针，指向 arr 首元素
 
    // sizeof(arr) 返回整个数组的大小：5 * sizeof(int) = 20
    cout << "sizeof(arr) = " << sizeof(arr) << endl;   // 输出 20
 
    // sizeof(p) 返回指针变量自身的大小（64位系统通常为8）
    cout << "sizeof(p)   = " << sizeof(p) << endl;     // 输出 8
 
    // 利用此特性计算数组元素个数（仅限数组未 decay 时有效）
    size_t len = sizeof(arr) / sizeof(arr[0]);          // 20 / 4 = 5
    cout << "元素个数 = " << len << endl;               // 输出 5
 
    return 0;
}

#include <iostream>
using namespace std;
 
int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    int* p = arr;
 
    // &arr 的类型是 int(*)[5] —— 指向"含5个int的数组"的指针
    // &p   的类型是 int**     —— 指向"int指针"的指针
 
    cout << "arr  = " << arr << endl;    // 首元素地址，如 0x1000
    cout << "&arr = " << &arr << endl;   // 数值相同，但类型是 int(*)[5]
 
    // 虽然数值相同，但 +1 的步长完全不同！
    cout << "arr + 1  = " << (arr + 1) << endl;  // 0x1000 + 4  = 0x1004（跳过1个int）
    cout << "&arr + 1 = " << (&arr + 1) << endl;  // 0x1000 + 20 = 0x1014（跳过整个数组）
 
    return 0;
}

int arr[5] = {1, 2, 3, 4, 5};
int brr[5] = {6, 7, 8, 9, 10};
int* p = arr;
 
p = brr;     // ✅ 合法：指针变量可以重新指向另一个数组
// arr = brr; // ❌ 编译错误：数组名不是可修改的左值
// arr++;     // ❌ 编译错误：不能对数组名做自增
p++;         // ✅ 合法：指针可以自增，现在 p 指向 brr[1]

#include <iostream>
using namespace std;
 
int main() {
    int arr[5] = {10, 20, 30, 40, 50};
 
    // 以下四种写法完全等价，都访问第 3 个元素（值为 30）
    cout << arr[2] << endl;          // 下标访问，最常见写法
    cout << *(arr + 2) << endl;      // 指针算术 + 解引用
    cout << *(2 + arr) << endl;      // 加法交换律，仍然合法
    cout << 2[arr] << endl;          // 等价于 *(2 + arr)，语法合法但可读性极差
 
    // 用指针遍历数组
    int* p = arr;                    // p 指向 arr[0]
    for (int i = 0; i < 5; i++) {
        // p[i] 等价于 *(p + i) 等价于 arr[i]
        cout << "p[" << i << "] = " << p[i] << "  ";
        cout << "*(p+" << i << ") = " << *(p + i) << endl;
    }
 
    return 0;
}

#include <iostream>
using namespace std;
 
int main() {
    int arr[5] = {10, 20, 30, 40, 50};
    int n = 5;                              // 数组元素个数
 
    // ========== 方法一：下标法 ==========
    // 最直观，适合大多数场景
    cout << "方法一（下标法）: ";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";              // 编译器翻译为 *(arr + i)
    }
    cout << endl;
 
    // ========== 方法二：指针偏移法 ==========
    // 用固定基址 + 偏移量，语义与方法一等价
    cout << "方法二（指针偏移法）: ";
    for (int i = 0; i < n; i++) {
        cout << *(arr + i) << " ";          // 手动指针算术
    }
    cout << endl;
 
    // ========== 方法三：指针递增法 ==========
    // 用一个移动的指针，每次 ++ 前进一个元素
    cout << "方法三（指针递增法）: ";
    int* begin = arr;                       // 指向首元素
    int* end = arr + n;                     // 指向"尾后"位置（past-the-end）
    for (int* p = begin; p != end; p++) {   // p 从 begin 走到 end
        cout << *p << " ";                  // 解引用当前元素
    }
    cout << endl;
 
    return 0;
}

#include <iostream>
using namespace std;
 
// 以下三种函数签名在编译器眼中完全等价！
// 它们接收的都是一个 int* 指针，而非数组。
void func_v1(int arr[5])  { cout << "sizeof = " << sizeof(arr) << endl; }
void func_v2(int arr[])   { cout << "sizeof = " << sizeof(arr) << endl; }
void func_v3(int* arr)    { cout << "sizeof = " << sizeof(arr) << endl; }
 
int main() {
    int data[5] = {1, 2, 3, 4, 5};
 
    cout << "main 中 sizeof(data) = " << sizeof(data) << endl;  // 20
 
    func_v1(data);   // 输出 8（64位系统），已经 decay 了！
    func_v2(data);   // 输出 8，同上
    func_v3(data);   // 输出 8，同上
 
    return 0;
}

#include <iostream>
using namespace std;
 
// 正确做法：额外传一个 size 参数
void printArray(const int* arr, size_t size) {   // const 防止修改
    for (size_t i = 0; i < size; i++) {          // 用传入的 size 控制循环
        cout << arr[i] << " ";                   // 下标访问仍然可用
    }
    cout << endl;
}
 
int main() {
    int data[5] = {10, 20, 30, 40, 50};
    // 在 main 中计算长度，然后传入
    printArray(data, sizeof(data) / sizeof(data[0]));  // 传入 5
    return 0;
}

#include <iostream>
using namespace std;
 
int main() {
    // ========== 指针数组（Array of Pointers）==========
    int a = 1, b = 2, c = 3;
    int* ptrArr[3];          // 声明一个数组，包含 3 个 int* 元素
    ptrArr[0] = &a;          // 第 0 个指针指向变量 a
    ptrArr[1] = &b;          // 第 1 个指针指向变量 b
    ptrArr[2] = &c;          // 第 2 个指针指向变量 c
 
    for (int i = 0; i < 3; i++) {
        cout << *ptrArr[i] << " ";   // 解引用每个指针，输出: 1 2 3
    }
    cout << endl;
 
    // ========== 数组指针（Pointer to Array）==========
    int arr[5] = {10, 20, 30, 40, 50};
    int (*pArr)[5] = &arr;   // pArr 是指向"含5个int的数组"的指针
 
    // 解引用 pArr 得到整个数组，再用下标访问
    cout << (*pArr)[2] << endl;       // 输出 30
 
    // pArr + 1 会跳过 5*4=20 字节（跳过整个数组）
    cout << "pArr     = " << pArr << endl;
    cout << "pArr + 1 = " << pArr + 1 << endl;  // 地址差 20
 
    return 0;
}

#include <iostream>
using namespace std;
 
// 二维数组在参数传递时 decay 为"数组指针"
// matrix 的类型实际是 int(*)[4]，即指向"含4个int的数组"的指针
void print2D(int (*matrix)[4], int rows) {
    for (int i = 0; i < rows; i++) {         // 遍历每一行
        for (int j = 0; j < 4; j++) {        // 遍历每一列
            cout << matrix[i][j] << "\t";    // matrix[i] 取出第i行数组，[j]再取元素
        }
        cout << endl;
    }
}
 
int main() {
    // 声明 3x4 的二维数组
    int matrix[3][4] = {
        {1,  2,  3,  4},
        {5,  6,  7,  8},
        {9, 10, 11, 12}
    };
 
    // matrix decay 为 int(*)[4]
    print2D(matrix, 3);
 
    return 0;
}

#include <iostream>
#include <iterator>   // std::begin, std::end
using namespace std;
 
int main() {
    int arr[5] = {50, 40, 30, 20, 10};
 
    // std::begin 返回指向首元素的指针
    // std::end   返回指向尾后位置的指针
    int* first = begin(arr);     // 等价于 arr
    int* last  = end(arr);       // 等价于 arr + 5
 
    cout << "元素个数: " << (last - first) << endl;   // 指针相减得到元素间距: 5
 
    // 用 begin/end 遍历
    for (int* p = begin(arr); p != end(arr); ++p) {
        cout << *p << " ";       // 输出: 50 40 30 20 10
    }
    cout << endl;
 
    return 0;
}

#include <iostream>
using namespace std;
 
void mystery(int arr[10]) {
    cout << sizeof(arr) << " ";
}
 
int main() {
    int data[10] = {};
    cout << sizeof(data) << " ";
    mystery(data);
    cout << sizeof(&data) << " ";
    cout << sizeof(*data) << endl;
    return 0;
}

#include <iostream>
 
int main() {
    int a = 42;          // 声明一个整型变量 a，值为 42
    int& ref = a;        // 声明一个引用 ref，绑定到变量 a（ref 是 a 的别名）
 
    std::cout << "a   = " << a   << std::endl;   // 输出: 42
    std::cout << "ref = " << ref << std::endl;   // 输出: 42（ref 和 a 是同一个东西）
 
    ref = 100;           // 通过引用修改值，等价于 a = 100
    std::cout << "a   = " << a   << std::endl;   // 输出: 100（a 的值被引用修改了）
 
    a = 200;             // 通过原变量修改值
    std::cout << "ref = " << ref << std::endl;   // 输出: 200（引用同步反映变化）
 
    // 验证地址：引用和原变量指向完全相同的内存地址
    std::cout << "&a   = " << &a   << std::endl; // 两者地址完全一致
    std::cout << "&ref = " << &ref << std::endl; // 两者地址完全一致
 
    return 0;
}

int a = 10;
int& ref = a;    // ✅ 正确：声明时立刻绑定到 a
// int& ref2;    // ❌ 编译错误！引用必须在声明时初始化

int a = 10;
int b = 20;
int& ref = a;    // ref 绑定到 a
 
ref = b;         // ⚠️ 这不是让 ref 改为绑定 b！
                 // 这是把 b 的值(20)赋给 a！
                 // 此时 a == 20, b == 20, ref 仍然是 a 的别名
 
std::cout << "a = " << a << std::endl;    // 输出: 20
std::cout << "&ref == &a ? " << (&ref == &a) << std::endl;  // 输出: 1 (true)
std::cout << "&ref == &b ? " << (&ref == &b) << std::endl;  // 输出: 0 (false)

// int& ref = 42;       // ❌ 编译错误！42 是右值（Rvalue），不能绑定到非 const 左值引用
const int& cref = 42;   // ✅ 正确：const 引用可以绑定到右值（编译器会创建临时变量）

// --- 你写的 C++ 代码 ---
int a = 42;
int& ref = a;       // 引用
ref = 100;           // 通过引用修改
 
// --- 编译器在底层大致做的事情（伪代码） ---
int a = 42;
int* const ref = &a; // 引用被实现为一个 int* const（指向不可变的指针）
*ref = 100;          // 通过解引用指针修改

int a = 10;
 
// 指针：可以不初始化（危险！），也可以初始化为 nullptr
int* p;             // ⚠️ 未初始化，指向随机地址（野指针）
int* p2 = nullptr;  // ✅ 初始化为空
int* p3 = &a;       // ✅ 初始化指向 a
 
// 引用：必须在声明时绑定
int& ref = a;       // ✅ 唯一合法的声明方式
// int& ref2;       // ❌ 编译失败

int a = 10, b = 20;
 
// 指针：可以随时改变指向
int* p = &a;        // p 指向 a
p = &b;             // p 改为指向 b ✅
 
// 引用：绑定后无法更改
int& ref = a;       // ref 绑定到 a
ref = b;            // ⚠️ 这是把 b 的值赋给 a，不是重新绑定！
                    // 结果：a == 20, ref 仍然是 a 的别名

int a = 10;
int* p = &a;        // 指针需要 & 取地址
int& ref = a;       // 引用直接用变量名
 
// 修改值
*p = 20;            // 指针需要 * 解引用才能修改目标值
ref = 20;           // 引用直接赋值，语法和普通变量完全一致
 
// 访问结构体成员（假设有 struct S { int x; }; S s; ）
// S* ps = &s;
// ps->x = 10;     // 指针用箭头运算符 ->
// S& rs = s;
// rs.x = 10;      // 引用用点运算符 .（和普通对象一样）

int* p = nullptr;   // ✅ 指针可以为空
// 使用前必须检查
if (p != nullptr) {
    *p = 10;        // 安全访问
}
 
// 引用不能为 null（没有语法支持绑定到"空"）
// int& ref = *nullptr; // ⚠️ 语法上可写，但这是未定义行为（UB），绝对禁止！

int a = 10;
 
// 指针可以有多级：指向指针的指针
int* p = &a;        // 一级指针
int** pp = &p;      // 二级指针（指向指针的指针）
int*** ppp = &pp;   // 三级指针（指向指向指针的指针）
 
// 引用没有多级概念
int& ref = a;       // 一级引用
// int&& rref = ref; // ⚠️ 这不是"引用的引用"！这是右值引用（C++11新特性），完全不同的概念
int& ref2 = ref;    // ✅ 这只是让 ref2 也绑定到 a，不存在"二级引用"

int a = 10;
int* p = &a;
int& ref = a;
 
std::cout << sizeof(p)   << std::endl;  // 输出: 8（64位系统上指针占 8 字节）
std::cout << sizeof(ref) << std::endl;  // 输出: 4（返回的是 a 的大小，即 int 的大小）
std::cout << sizeof(a)   << std::endl;  // 输出: 4

#include <iostream>
#include <string>
 
// 通过引用传递：避免拷贝 string（string 可能很长，拷贝代价高）
// 同时允许函数修改原始字符串
void toUpperCase(std::string& str) {  // str 是调用者传入变量的别名
    for (char& c : str) {             // 范围 for 中也用引用，直接修改每个字符
        if (c >= 'a' && c <= 'z') {   // 如果是小写字母
            c -= 32;                  // 转为大写（ASCII 差值为 32）
        }
    }
}
 
int main() {
    std::string name = "hello world";     // 原始字符串
    toUpperCase(name);                     // 传入引用，函数直接修改 name
    std::cout << name << std::endl;        // 输出: HELLO WORLD
    return 0;
}

#include <iostream>
#include <vector>
 
// const 引用：承诺不修改 vec，同时避免拷贝整个 vector
void printVector(const std::vector<int>& vec) {  // vec 是只读别名
    for (const int& val : vec) {                  // 每个元素也用 const 引用，避免拷贝
        std::cout << val << " ";                  // 只读访问
    }
    std::cout << std::endl;
    // vec.push_back(1);  // ❌ 编译错误！const 引用禁止修改
}
 
int main() {
    std::vector<int> data = {1, 2, 3, 4, 5};  // 创建一个 vector
    printVector(data);                          // 传入 const 引用
    return 0;
}

#include <iostream>
#include <vector>
 
class MyArray {
private:
    int data[5] = {10, 20, 30, 40, 50};  // 内部数组
 
public:
    // 返回引用：允许调用者直接读写内部元素
    int& at(int index) {                  // 返回类型是 int&
        return data[index];               // 返回的是数组元素本身（别名），而非拷贝
    }
 
    // const 版本：只允许读取
    const int& at(int index) const {      // const 成员函数中返回 const 引用
        return data[index];
    }
};
 
int main() {
    MyArray arr;
    std::cout << arr.at(2) << std::endl;  // 输出: 30（读取）
    arr.at(2) = 999;                       // 通过引用直接修改内部数组！
    std::cout << arr.at(2) << std::endl;  // 输出: 999（已被修改）
    return 0;
}

// ❌ 严重错误示范！
int& createValue() {
    int local = 42;         // local 是局部变量，存储在栈上
    return local;           // 返回局部变量的引用 → 函数返回后 local 被销毁！
}   // ← local 的生命周期在这里结束
 
int main() {
    int& ref = createValue();  // ref 绑定到已销毁的内存 → 未定义行为（UB）！
    std::cout << ref;           // 可能输出 42，也可能输出垃圾值，也可能崩溃
    return 0;
}

#include <iostream>
#include <vector>
 
int main() {
    std::vector<int> nums = {1, 2, 3, 4, 5};
 
    // 不用引用：val 是每个元素的拷贝，修改 val 不影响原容器
    for (int val : nums) {
        val *= 2;            // 只修改了拷贝，nums 不变
    }
    // nums 仍然是 {1, 2, 3, 4, 5}
 
    // 使用引用：val 是每个元素的别名，修改 val 直接修改原容器
    for (int& val : nums) {
        val *= 2;            // 直接修改 nums 中的元素
    }
    // nums 变为 {2, 4, 6, 8, 10}
 
    // 只读遍历：使用 const 引用，既避免拷贝又防止意外修改
    for (const int& val : nums) {
        std::cout << val << " ";  // 只读访问
    }
    // 输出: 2 4 6 8 10
 
    return 0;
}

int a = 10;
int& lref = a;              // 左值引用：绑定到左值（有名字、有地址的对象）
// int& lref2 = 42;         // ❌ 不能绑定到右值
 
int&& rref = 42;            // 右值引用：绑定到右值（临时值、即将消亡的值）
// int&& rref2 = a;         // ❌ 不能直接绑定到左值
 
const int& cref = 42;       // const 左值引用：特殊，既能绑定左值也能绑定右值

const int& ref = 42;   // ✅ 特殊规则：const 引用会延长临时值的生命周期
                        // 临时值 42 的生命周期被延长到 ref 的作用域结束
std::cout << ref;       // 安全，输出 42

double pi = 3.14;
// const int& ref = pi;   // 编译器会创建一个 int 临时变量 = (int)3.14 = 3
                           // ref 绑定到这个临时变量，而不是 pi！
                           // 修改 pi 不会影响 ref，ref 也不是 pi 的别名

#include <iostream>
 
int main() {
    int a = 10;
    int b = 20;
    int& ref = a;
    ref = b;
    b = 30;
    std::cout << a << " " << ref << " " << b << std::endl;
    return 0;
}

const int x = 42;   // x 被锁定为 42
x = 100;             // ❌ 编译错误：不能修改 const 变量

int a = 10;                // 定义普通整型变量 a，值为 10
int b = 20;                // 定义普通整型变量 b，值为 20
 
const int* p = &a;         // p 指向 a，但承诺"不通过 p 修改 a"
 
// *p = 100;               // ❌ 编译错误！不能通过 p 修改所指向的数据
std::cout << *p << "\n";   // ✅ 可以读取：输出 10
 
p = &b;                    // ✅ 可以改变 p 的指向，让它指向 b
std::cout << *p << "\n";   // ✅ 输出 20
 
a = 999;                   // ✅ 直接修改 a 本身是完全合法的！
std::cout << *p << "\n";   // 输出 20（p 已经指向 b，与 a 无关）

//  变量       地址         值
// ┌────────┬────────────┬─────────┐
// │   a    │  0x1000    │   10    │  ← a 本身不是 const，可以直接改
// ├────────┼────────────┼─────────┤
// │   b    │  0x1004    │   20    │
// ├────────┼────────────┼─────────┤
// │   p    │  0x1008    │ 0x1000  │  ← p 存的地址可以改（指向 a 或 b）
// └────────┴────────────┴─────────┘
//
//   const 锁住的是：通过 *p 去写入的行为
//   const 没有锁：p 本身存储的地址值

// 打印数组内容：承诺不修改数组中的任何元素
void printArray(const int* arr, int size) {
    for (int i = 0; i < size; ++i) {       // 遍历每个元素
        // arr[i] = 0;                      // ❌ 如果取消注释，编译报错
        std::cout << arr[i] << " ";         // ✅ 只读访问，完全合法
    }
    std::cout << "\n";                      // 换行
}