第 12 章　调试、构建与测试

#include <iostream>
#include <memory>
int main() {
    const int n = 4;
    std::unique_ptr<int[]> a(new int[n]{1, 2, 4, 5});   // 用智能指针管理
    int sum = 0;
    for (int i = 0; i < n; ++i) {                       // i <= n 就是越界
        sum += a[i];
    }
    std::cout << "sum=" << sum << '\n';
    return 0;
}

解析　原始代码里 a[4] 是越界（合法下标是 0~3），而 new 之后没有 delete 会造成泄漏。开 sanitizer 后运行会直接指出 stack/ heap-buffer-overflow 或 detected memory leaks，按提示改完即通过。

#include <iostream>
#include <memory>

struct Node {
    int value{};
    Node* next = nullptr;
};

int main() {
    Node a{3, nullptr};
    Node b{1, nullptr};
    Node c{-1, nullptr};
    Node d{2, nullptr};
    a.next = &b;
    b.next = &c;
    c.next = &d;

    for (const Node* p = &a; p != nullptr; p = p->next) {
        std::cout << p->value << " -> ";
    }
    std::cout << "null\n";
    return 0;
}

解析　崩溃的经典原因是链路断在某个节点上（指针为 nullptr）却继续解引用。用 gdb 的 bt 看到崩溃行、用 p 变量名 看到空指针后，把断链补上即可；修好后的循环必须严格用 p != nullptr 作终止条件。

cmake_minimum_required(VERSION 3.16)
project(square_demo CXX)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

add_executable(app util.cpp main.cpp)
target_compile_options(app PRIVATE -Wall -Wextra -Wpedantic)

option(ENABLE_ASAN "打开 AddressSanitizer" OFF)
if(ENABLE_ASAN)
  target_compile_options(app PRIVATE -fsanitize=address,undefined -g)
  target_link_options(app PRIVATE -fsanitize=address,undefined)
endif()

解析　构建命令：cmake -S . -B build 然后 cmake --build build；运行 ./build/app（Windows 用 .\build\app.exe）。目录结构保持 util.h / util.cpp / main.cpp / CMakeLists.txt 平铺即可。

#include <cassert>
#include <cstddef>
#include <functional>
#include <iostream>
#include <stdexcept>
#include <string>
#include <vector>

class IntArray {
public:
    explicit IntArray(std::size_t n) : size_(n), data_(n > 0 ? new int[n]{} : nullptr) { }
    IntArray(const IntArray& o)
        : size_(o.size_), data_(o.size_ > 0 ? new int[o.size_]{} : nullptr) {
        for (std::size_t i = 0; i < size_; ++i) { data_[i] = o.data_[i]; }
    }
    IntArray& operator=(const IntArray& o) {
        if (this == &o) { return *this; }
        int* fresh = o.size_ > 0 ? new int[o.size_]{} : nullptr;
        for (std::size_t i = 0; i < o.size_; ++i) { fresh[i] = o.data_[i]; }
        delete[] data_;
        data_ = fresh;
        size_ = o.size_;
        return *this;
    }
    ~IntArray() { delete[] data_; }
    std::size_t size() const { return size_; }
    int& at(std::size_t i) {
        if (i >= size_) { throw std::out_of_range("IntArray::at"); }
        return data_[i];
    }
    int at(std::size_t i) const {
        if (i >= size_) { throw std::out_of_range("IntArray::at"); }
        return data_[i];
    }
private:
    std::size_t size_ = 0;
    int* data_ = nullptr;
};

struct Case { std::string name; std::function<void()> fn; };
std::vector<Case>& all() { static std::vector<Case> c; return c; }
struct AutoReg { AutoReg(const std::string& n, std::function<void()> f) { all().push_back({n, f}); } };
#define TEST(name) void name(); static AutoReg reg_##name(#name, name); void name()

TEST(ctor_zero) {
    IntArray a(3);
    assert(a.size() == 3);
    for (std::size_t i = 0; i < a.size(); ++i) { assert(a.at(i) == 0); }
}

TEST(copy_independent) {
    IntArray a(3);
    a.at(0) = 7;
    IntArray b = a;
    b.at(0) = 99;
    assert(a.at(0) == 7);            // 深拷贝：互不影响
    assert(b.at(0) == 99);
}

TEST(at_throws) {
    IntArray a(2);
    bool thrown = false;
    try { a.at(5); } catch (const std::out_of_range&) { thrown = true; }
    assert(thrown);
}

TEST(self_assign) {
    IntArray a(2);
    a.at(1) = 42;
    a = a;                            // 自赋值不能崩也不能变
    assert(a.size() == 2);
    assert(a.at(1) == 42);
}

int main() {
    int failed = 0;
    for (const auto& c : all()) {
        try { c.fn(); std::cout << "[PASS] " << c.name << '\n'; }
        catch (...) { ++failed; std::cout << "[FAIL] " << c.name << '\n'; }
    }
    std::cout << "failed=" << failed << '\n';
    return failed == 0 ? 0 : 1;
}

解析　注意用例的执行顺序和注册顺序一致（同一个 vector 里），所以输出顺序稳定；如果哪天输出顺序变了，说明有静态初始化顺序问题——这也是这套极简框架的一个已知局限。