第 4 章　指针、数组与内存模型

#include <iostream>
void swapPtr(int* a, int* b) {
    if (!a || !b) { return; }
    int t = *a;
    *a = *b;
    *b = t;
}
int main() {
    int x, y;
    std::cin >> x >> y;
    swapPtr(&x, &y);
    std::cout << x << ' ' << y << '\n';
    return 0;
}

解析　指针可能为空，使用前先判空；&x 取地址，*a 解引用。

#include <iostream>
int main() {
    int a = 1, b = 2;
    const int* p = &a;      // 指向常量的指针：不能改 *p
    // *p = 20;             // 非法：编译错误
    p = &b;                 // 合法：可以改指向
    std::cout << *p << '\n';   // 2：读一下，避免“变量未使用”警告
    int* const q = &a;      // 常量指针：不能改指向
    *q = 30;                // 合法：可以改值
    // q = &b;              // 非法：编译错误
    std::cout << a << '\n';   // 30
    std::cout << b << '\n';   // 2
    return 0;
}

解析　const int* 修饰的是 *p（值）；int* const 修饰的是 p 本身（指向）。

#include <iostream>
#include <vector>
int main() {
    int n;
    std::cin >> n;
    std::vector<int> v(n);
    for (int i = 0; i < n; ++i) { std::cin >> v[i]; }
    int mx = v[0];
    for (int x : v) { if (x > mx) { mx = x; } }
    std::cout << mx << '\n';
    return 0;
}

解析　动态长度优先 vector；范围 for 只读遍历最简洁。

#include <algorithm>
#include <iostream>
#include <string>
int main() {
    std::string s;
    std::cin >> s;
    std::string t = s;
    std::reverse(t.begin(), t.end());
    std::cout << t << '\n';
    for (int i = 0, j = (int)s.size() - 1; i < j; ++i, --j) {
        std::swap(s[i], s[j]);
    }
    std::cout << s << '\n';
    return 0;
}

解析　双指针首尾交换是手写反转的标准写法；std::swap 在 <utility>（algorithm 也会带进来）。

#include <iostream>
int main() {
    int* arr = new int[5]{1, 2, 3, 4, 5};
    int sum = 0;
    for (int i = 0; i < 5; ++i) { sum += arr[i]; }
    std::cout << sum << '\n';
    delete[] arr;
    return 0;
}

解析　new[] 和 delete[] 必须配对；混用 free/delete 是未定义行为。

#include <algorithm>
#include <iostream>
int main() {
    int n;
    std::cin >> n;
    int* arr = new int[n];
    for (int i = 0; i < n; ++i) { std::cin >> arr[i]; }
    std::sort(arr, arr + n);
    for (int i = 0; i < n; ++i) {
        std::cout << arr[i] << (i + 1 == n ? '\n' : ' ');
    }
    delete[] arr;
    return 0;
}

解析　指针算术 arr + n 是合法的（同一数组内）；删除后不要再碰 arr。

#include <iostream>
#include <memory>
struct Node {
    int value = 0;
    std::unique_ptr<Node> next;
};
int main() {
    auto head = std::make_unique<Node>();
    head->value = 1;
    head->next = std::make_unique<Node>();
    head->next->value = 2;
    std::cout << head->value << ' ' << head->next->value << '\n';
    return 0;   // 离开作用域自动释放整条链
}

解析　unique_ptr 析构时递归释放 next，整条链自动回收，这就是 RAII。

#include <iostream>
#include <memory>
struct Node { int value = 0; };
int main() {
    std::shared_ptr<Node> a = std::make_shared<Node>();
    std::shared_ptr<Node> b = a;   // 计数 2
    {
        std::shared_ptr<Node> c = a;   // 计数 3
        std::cout << a.use_count() << '\n';   // 3
    }                                // c 离开作用域，计数 2
    std::cout << a.use_count() << '\n';   // 2
    return 0;
}

解析　shared_ptr 引用计数归零才释放；要共享所有权就从同一个指针拷贝，绝不用裸指针 new 两次。

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

void reverse(int* first, int* last) {   // [first, last)
    if (first == last) { return; }
    --last;                             // 变成闭区间再交换
    while (first < last) {
        std::swap(*first, *last);
        ++first;
        --last;
    }
}

long long sum(const int* first, const int* last) {
    long long s = 0;
    for (const int* p = first; p != last; ++p) { s += *p; }
    return s;
}

int main() {
    int n{};
    std::cin >> n;
    std::unique_ptr<int[]> a(new int[n]);
    for (int i = 0; i < n; ++i) { std::cin >> a[i]; }
    reverse(a.get(), a.get() + n);
    for (int i = 0; i < n; ++i) { std::cout << a[i] << (i + 1 == n ? '\n' : ' '); }
    std::cout << "sum=" << sum(a.get(), a.get() + n) << '\n';
    return 0;
}

解析　裸指针只在函数内部流转，所有权始终在 unique_ptr 手里；这样即使中间抛异常也不会泄漏。