1
2
3
4

// 不经过单元测试的代码 vs 经过单元测试的代码
// 区别就像:
// 没测试: "我确信这段代码是对的" —— 盲目自信
// 有测试: "我证明了这段代码是对的" —— 证据说话

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

// math_utils.h
#pragma once

int add(int a, int b) {
    return a + b;
}

int divide(int a, int b) {
    if (b == 0) {
        throw std::runtime_error("Division by zero");
    }
    return a / b;
}

// factorial 函数（正确实现）
int factorial(int n) {
    if (n < 0) {
        throw std::invalid_argument("Negative input");
    }
    int result = 1;
    for (int i = 2; i <= n; ++i) {
        result *= i;
    }
    return result;
}

// 手动测试驱动开发（TDD）—— 先写测试再写实现
int main() {
    // 测试 add
    if (add(2, 3) != 5) {
        std::cerr << "FAIL: add(2, 3) expected 5" << std::endl;
        return 1;
    }
    if (add(-1, 1) != 0) {
        std::cerr << "FAIL: add(-1, 1) expected 0" << std::endl;
        return 1;
    }
    std::cout << "PASS: add tests" << std::endl;

    // 测试 divide
    if (divide(10, 2) != 5) {
        std::cerr << "FAIL: divide(10, 2) expected 5" << std::endl;
        return 1;
    }
    try {
        divide(10, 0);
        std::cerr << "FAIL: divide(10, 0) should throw" << std::endl;
        return 1;
    } catch (const std::runtime_error&) {
        std::cout << "PASS: divide exception test" << std::endl;
    }

    // 测试 factorial
    if (factorial(5) != 120) {
        std::cerr << "FAIL: factorial(5) expected 120, got " << factorial(5) << std::endl;
        return 1;
    }
    std::cout << "PASS: factorial(5) = 120" << std::endl;

    std::cout << "\nAll manual tests passed!" << std::endl;
    return 0;
}

1
2
3
4
5
6

# 使用 vcpkg 安装
vcpkg install gtest

# 或者下载源码编译
git clone https://github.com/google/googletest.git
cd googletest && cmake -B build && cmake --build build

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

// gtest_demo.cpp
#include <gtest/gtest.h>
#include <gmock/gmock.h>

// 被测试的代码
int add(int a, int b) {
    return a + b;
}

double divide(double a, double b) {
    if (b == 0.0) {
        throw std::runtime_error("Division by zero");
    }
    return a / b;
}

std::string greet(const std::string& name) {
    if (name.empty()) {
        return "Hello, Stranger!";
    }
    return "Hello, " + name + "!";
}

// ========== 测试用例 ==========

// TEST(测试套件名, 测试用例名)
// 套件名和用例名必须是有效的C++标识符（不能有空格）
TEST(MathBasic, AddPositive) {
    EXPECT_EQ(add(2, 3), 5);
    EXPECT_EQ(add(0, 0), 0);
    EXPECT_EQ(add(-5, 5), 0);
}

TEST(MathBasic, AddBoundary) {
    EXPECT_EQ(add(INT_MAX, 0), INT_MAX);
    EXPECT_EQ(add(INT_MIN, 0), INT_MIN);
    // 注意：add(INT_MAX, 1) 会溢出，这是undefined behavior
    // 在测试中我们要么避开边界，要么明确知道溢出行为
}

TEST(MathBasic, Divide) {
    EXPECT_DOUBLE_EQ(divide(10.0, 2.0), 5.0);
    EXPECT_DOUBLE_EQ(divide(1.0, 3.0), 1.0 / 3.0);  // divide返回1.0/3.0，与字面量1.0/3.0比较；注意两者求值路径可能不同，这里仅作示例
}

TEST(MathBasic, DivideByZero) {
    // EXPECT_THROW: 期望抛出指定异常
    EXPECT_THROW(divide(10.0, 0.0), std::runtime_error);
    // EXPECT_ANY_THROW: 期望抛出任何异常
    EXPECT_ANY_THROW(divide(1.0, 0.0));
}

TEST(StringUtil, Greet) {
    EXPECT_EQ(greet("World"), "Hello, World!");
    EXPECT_EQ(greet("C++"), "Hello, C++!");
}

TEST(StringUtil, GreetEmpty) {
    EXPECT_EQ(greet(""), "Hello, Stranger!");
}

// ========== 测试夹具（Fixture）==========
// 当多个测试需要共享相同的数据设置时，使用TEST_F

class StackTest : public ::testing::Test {
protected:
    // SetUp: 每个测试用例运行前调用
    void SetUp() override {
        stack.push(1);
        stack.push(2);
        stack.push(3);
    }

    // TearDown: 每个测试用例运行后调用
    void TearDown() override {
        // 清理资源（如果需要）
    }

    std::stack<int> stack;
};

TEST_F(StackTest, InitialSize) {
    EXPECT_EQ(stack.size(), 3);
}

TEST_F(StackTest, Pop) {
    stack.pop();
    EXPECT_EQ(stack.size(), 2);
    EXPECT_EQ(stack.top(), 2);
}

TEST_F(StackTest, PopAll) {
    while (!stack.empty()) {
        stack.pop();
    }
    EXPECT_TRUE(stack.empty());
}

// ========== 参数化测试 ==========
// 当你需要用不同参数测试同一个逻辑时

class IsPrimeTest : public ::testing::TestWithParam<int> {
};

// 被测试函数
bool isPrime(int n) {
    if (n < 2) return false;
    for (int i = 2; i <= std::sqrt(n); ++i) {
        if (n % i == 0) return false;
    }
    return true;
}

TEST_P(IsPrimeTest, CheckPrimes) {
    int n = GetParam();
    EXPECT_TRUE(isPrime(n)) << "Failed for n = " << n;
}

// 定义测试参数
INSTANTIATE_TEST_SUITE_P(
    PrimeValues,
    IsPrimeTest,
    ::testing::Values(2, 3, 5, 7, 11, 13, 17, 19, 23, 29)
);

INSTANTIATE_TEST_SUITE_P(
    NonPrimeValues,
    IsPrimeTest,
    ::testing::Values(0, 1, 4, 6, 8, 9, 10, 12, 15)
);

int main(int argc, char **argv) {
    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}

1
2

g++ -std=c++17 gtest_demo.cpp -lgtest -lgtest_main -pthread -o gtest_demo
./gtest_demo

1
2
3

EXPECT_DOUBLE_EQ(a, b);      // 精度约15位
EXPECT_FLOAT_EQ(a, b);       // 精度约7位
EXPECT_NEAR(a, b, abs_error); // 允许绝对误差

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

// catch2_demo.cpp
#define CATCH_CONFIG_MAIN
#include <catch2/catch_test_macros.hpp>
#include <catch2/catch_approx.hpp>

int add(int a, int b) { return a + b; }
int subtract(int a, int b) { return a - b; }

using Catch::Approx;

// ========== 基本测试 ==========

TEST_CASE("add function", "[math]") {
    REQUIRE(add(2, 3) == 5);
    REQUIRE(add(-1, 1) == 0);
    REQUIRE(add(0, 0) == 0);
}

TEST_CASE("subtract function", "[math]") {
    CHECK(subtract(5, 3) == 2);
    CHECK(subtract(3, 5) == -2);
    CHECK(subtract(0, 0) == 0);
}

// ========== SECTION: 共享setup的不同路径 ==========

struct StatResult {
    int sum;
    double average;
};

StatResult calcStats(const std::vector<int>& vals) {
    if (vals.empty()) {
        return {0, 0.0};
    }
    int sum = 0;
    for (int v : vals) sum += v;
    return {sum, static_cast<double>(sum) / vals.size()};
}

TEST_CASE("calcStats", "[stats]") {
    StatResult r;

    SECTION("empty vector") {
        r = calcStats({});
        CHECK(r.sum == 0);
        CHECK(r.average == 0.0);
    }

    SECTION("single element") {
        r = calcStats({42});
        CHECK(r.sum == 42);
        CHECK(r.average == 42.0);
    }

    SECTION("multiple elements") {
        r = calcStats({1, 2, 3, 4, 5});
        CHECK(r.sum == 15);
        CHECK(r.average == 3.0);
    }

    SECTION("negative numbers") {
        r = calcStats({-5, -3, -1});
        CHECK(r.sum == -9);
        CHECK(r.average == Approx(-3.0));
    }
}

// ========== 浮点数近似比较 ==========

double quadraticRoot(double a, double b, double c) {
    double discriminant = b * b - 4 * a * c;
    if (discriminant < 0) return 0;
    return (-b + std::sqrt(discriminant)) / (2 * a);
}

TEST_CASE("quadratic equation solver", "[math]") {
    SECTION("x^2 - 4 = 0 has roots x=2 and x=-2") {
        // 只测试正根
        double root = quadraticRoot(1, 0, -4);
        CHECK(root == Approx(2.0).margin(1e-10));
    }

    SECTION("x^2 + 1 = 0 has no real roots") {
        double root = quadraticRoot(1, 0, 1);
        CHECK(root == 0);
    }
}

// ========== 异常测试 ==========

int divide_throw(int a, int b) {
    if (b == 0) throw std::invalid_argument("divisor is zero");
    return a / b;
}

TEST_CASE("divide throws on zero", "[exceptions]") {
    CHECK_THROWS_AS(divide_throw(10, 0), std::invalid_argument);
    CHECK_THROWS_WITH(divide_throw(10, 0), "divisor is zero");
    CHECK_NOTHROW(divide_throw(10, 2));  // 不应抛出
}

// ========== 标签和过滤 ==========

TEST_CASE("vector operations", "[container][vector]") {
    std::vector<int> v{1, 2, 3};
    
    SECTION("push_back") {
        v.push_back(4);
        REQUIRE(v.size() == 4);
        REQUIRE(v[3] == 4);
    }
    
    SECTION("pop_back") {
        v.pop_back();
        REQUIRE(v.size() == 2);
    }
}

TEST_CASE("string operations", "[container][string]") {
    std::string s = "hello";
    REQUIRE(s.length() == 5);
}

1
2
3
4
5
6
7
8
9

# Catch2 v3 方式
g++ -std=c++17 -I/path/to/catch2/include catch2_demo.cpp -o catch2_demo
./catch2_demo

# 只运行带 [math] 标签的测试
./catch2_demo "[math]"

# 运行除 [exceptions] 外的所有测试
./catch2_demo "~[exceptions]"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

// ============== 接口 ==============
struct IDatabase {
    virtual ~IDatabase() = default;
    virtual User findUserById(int id) const = 0;
    virtual bool saveUser(const User& user) = 0;
    virtual int countUsers() const = 0;
};

struct User {
    int id;
    std::string name;
    std::string email;
};

// ============== 真实实现（生产用）==============
class RealDatabase : public IDatabase {
    std::map<int, User> users_;
public:
    User findUserById(int id) const override {
        auto it = users_.find(id);
        if (it == users_.end()) throw std::runtime_error("User not found");
        return it->second;
    }
    bool saveUser(const User& user) override {
        users_[user.id] = user;
        return true;
    }
    int countUsers() const override { return users_.size(); }
};

// ============== 模拟实现（测试用）==============
#include <gmock/gmock.h>

class MockDatabase : public IDatabase {
public:
    mutable std::map<int, User> users_;
    mutable std::vector<std::pair<std::string, std::any>> calls_;  // 记录调用

    MOCK_METHOD(User, findUserById, (int id), (const, override));
    MOCK_METHOD(bool, saveUser, (const User&), (override));  // 注意：参数名省略，避免EXPECT_CALL匹配问题
    MOCK_METHOD(int, countUsers, (), (const, override));

    // 便捷的预设行为
    void addUser(const User& user) {
        users_[user.id] = user;
    }
};

// ============== 使用mock测试 ============

class UserService {
    IDatabase& db_;
public:
    explicit UserService(IDatabase& db) : db_(db) {}

    std::string getUserDisplayName(int id) {
        User u = db_.findUserById(id);
        return u.name + " (" + u.email + ")";
    }

    bool registerUser(const std::string& name, const std::string& email) {
        if (name.empty() || email.empty()) return false;
        int nextId = db_.countUsers() + 1;
        User u{nextId, name, email};
        return db_.saveUser(u);
    }
};

TEST(UserServiceTest, GetUserDisplayName) {
    MockDatabase mock;
    User testUser{1, "Alice", "alice@example.com"};
    mock.addUser(testUser);

    EXPECT_CALL(mock, findUserById(1))
        .Times(1)
        .WillOnce(testing::Return(testUser));

    UserService service(mock);
    std::string display = service.getUserDisplayName(1);

    EXPECT_EQ(display, "Alice (alice@example.com)");
}

TEST(UserServiceTest, RegisterUser) {
    MockDatabase mock;
    EXPECT_CALL(mock, countUsers()).WillOnce(testing::Return(0));
    EXPECT_CALL(mock, saveUser(testing::_)).WillOnce(testing::Return(true));

    UserService service(mock);
    bool result = service.registerUser("Bob", "bob@example.com");

    EXPECT_TRUE(result);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

// TDD示例：为"计算器"写测试和实现

// Step 1: 先写测试（此时Calculator类还不存在）
TEST_CASE("calculator basic operations", "[tdd]") {
    Calculator calc;

    SECTION("add") {
        REQUIRE(calc.add(2, 3) == 5);
        REQUIRE(calc.add(-1, 1) == 0);
    }

    SECTION("subtract") {
        REQUIRE(calc.sub(5, 3) == 2);
        REQUIRE(calc.sub(3, 5) == -2);
    }
}

// 编译后会报错：Calculator类不存在（红）

// Step 2: 最少代码让测试通过
class Calculator {
public:
    int add(int a, int b) { return a + b; }
    int sub(int a, int b) { return a - b; }
};
// 现在测试通过了（绿）

// Step 3: 发现add(2,3)返回5是对的，但add(-1,1)呢？
// 实现里直接return a + b其实已经处理了（这步比较简单）
// 但TDD的精妙在于：你只实现了"被测试要求的功能"，
// 不会过度设计

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

// integration_test.cpp
// 假设我们有：
//   - DatabaseManager: 管理数据库连接
//   - UserRepository:  用户数据的CRUD操作
//   - UserService:     业务逻辑层

#include <catch2/catch_test_macros.hpp>
#include "DatabaseManager.h"
#include "UserRepository.h"
#include "UserService.h"

TEST_CASE("UserService + UserRepository integration", "[integration]") {
    // 使用测试数据库（而不是生产数据库）
    auto dbManager = std::make_unique<DatabaseManager>("test.db");
    dbManager->connect();
    dbManager->createTables();  // 初始化表结构

    UserRepository repo(*dbManager);
    UserService service(repo);

    SECTION("create and retrieve user") {
        bool created = service.createUser("Alice", "alice@example.com");
        REQUIRE(created == true);

        auto user = service.findUserByName("Alice");
        REQUIRE(user.has_value() == true);
        CHECK(user->email == "alice@example.com");
    }

    SECTION("duplicate email rejected") {
        service.createUser("Alice", "alice@example.com");
        bool duplicate = service.createUser("Bob", "alice@example.com");
        CHECK(duplicate == false);  // 业务逻辑应该拒绝重复email
    }

    // 测试结束后清理
    dbManager->dropTables();
    dbManager->disconnect();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

TEST_CASE("smoke tests - system is alive", "[smoke]") {
    Config config("config.json");
    REQUIRE(config.load() == true);  // 能加载配置

    DatabaseManager db("test.db");
    REQUIRE_NOTHROW(db.connect());   // 能连接数据库

    UserService service(db);
    REQUIRE(service.isHealthy() == true);  // 服务健康

    Logger logger("app.log");
    REQUIRE_NOTHROW(logger.info("Smoke test passed"));  // 日志正常
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

// fuzzer_demo.cpp - 简单模糊测试示例
#include <iostream>
#include <random>
#include <cstring>

// 假设这是你要测试的解析函数
struct ParseResult {
    bool success;
    int value;
    std::string error;
};

ParseResult parseConfig(const std::string& input) {
    // 简单解析格式: "key=value"
    auto eqPos = input.find('=');
    if (eqPos == std::string::npos) {
        return {false, 0, "Missing '='"};
    }

    std::string key = input.substr(0, eqPos);
    std::string val = input.substr(eqPos + 1);

    if (key != "port") {
        return {false, 0, "Unknown key"};
    }

    // stoi可能抛异常！
    try {
        int port = std::stoi(val);
        if (port < 0 || port > 65535) {
            return {false, 0, "Port out of range"};
        }
        return {true, port, ""};
    } catch (...) {
        return {false, 0, "Invalid number"};
    }
}

// 简单模糊测试器
void fuzzTest(int iterations = 10000) {
    std::mt19937 rng(42);  // 固定种子以便复现
    std::uniform_int_distribution<int> charDist(32, 126);  // 可打印ASCII

    int crashCount = 0;
    int successCount = 0;

    for (int i = 0; i < iterations; ++i) {
        // 生成随机字符串
        int len = std::uniform_int_distribution<int>(1, 50)(rng);
        std::string input;
        input.reserve(len);
        for (int j = 0; j < len; ++j) {
            input += static_cast<char>(charDist(rng));
        }

        // 测试解析
        auto result = parseConfig(input);
        if (result.success) {
            successCount++;
            std::cout << "[OK] \"" << input << "\" -> port=" << result.value << std::endl;
        }
    }

    std::cout << "\nFuzzing complete: " << successCount << " successes out of " << iterations << std::endl;
}

// ========== 使用libFuzzer（更专业的模糊测试）==========
// libFuzzer是LLVM项目的一部分，配合AddressSanitizer效果更佳

extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
    // 将data转换为string
    std::string input(reinterpret_cast<const char*>(data), size);

    // 调用你要测试的函数
    auto result = parseConfig(input);

    // 如果你想触发crash来发现bug，可以这样做：
    // 但对于parseConfig，我们更关心返回值

    // LibFuzzer会自动变异输入，发现各种边界情况
    return 0;  // 返回0表示一切正常
}

1
2
3

# 假设parseConfig相关代码在fuzz_target.cpp中
clang++ -fsanitize=fuzzer,address -g fuzz_target.cpp -o fuzz_target
./fuzz_target -max_total_time=60  # 运行60秒

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

// bug_demo.cpp - 有bug的程序
#include <iostream>
#include <vector>
#include <memory>

class Widget {
public:
    int id;
    std::string name;
    Widget(int i, const std::string& n) : id(i), name(n) {
        std::cout << "Widget " << id << " created\n";
    }
    ~Widget() {
        std::cout << "Widget " << id << " destroyed\n";
    }
};

double average(const std::vector<int>& vals) {
    // BUG: 没有检查vals是否为空！
    double sum = 0;
    for (int v : vals) {
        sum += v;
    }
    return sum / vals.size();  // 除以0！NaN！
}

void processWidgets() {
    std::vector<std::unique_ptr<Widget>> widgets;

    widgets.push_back(std::make_unique<Widget>(1, "Alpha"));
    widgets.push_back(std::make_unique<Widget>(2, "Beta"));

    // BUG: 迭代器失效！对vector添加元素后，之前的迭代器可能失效
    for (auto it = widgets.begin(); it != widgets.end(); ++it) {
        std::cout << "Processing " << (*it)->name << "\n";
        if ((*it)->id == 1) {
            widgets.push_back(std::make_unique<Widget>(3, "Gamma"));  // 可能导致迭代器失效！
        }
    }

    std::cout << "Widget count: " << widgets.size() << "\n";
}

int main() {
    std::cout << "=== Average test ===\n";
    std::vector<int> empty;
    std::cout << "Average of empty: " << average(empty) << "\n";  // NaN

    std::vector<int> nums{1, 2, 3, 4, 5};
    std::cout << "Average of 1..5: " << average(nums) << "\n";

    std::cout << "\n=== Widget test ===\n";
    processWidgets();

    std::cout << "\n=== Done ===\n";
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# 编译带调试信息的版本
g++ -g -O0 -std=c++17 bug_demo.cpp -o bug_demo

# 启动GDB
gdb ./bug_demo

# 在GDB中：
(gdb) break main              # 在main函数设置断点
(gdb) run                     # 运行程序
(gdb) break average           # 在average函数设置断点
(gdb) continue                # 继续运行到下一个断点
(gdb) print vals              # 打印vals变量
(gdb) print vals.size()       # 打印size
(gdb) next                    # 执行下一行（不进入函数）
(gdb) step                    # 执行下一行（进入函数）
(gdb) backtrace               # 打印调用栈
(gdb) frame 1                 # 切换到栈帧1
(gdb) watch vals.size()       # 当vals.size()改变时暂停
(gdb) delete breakpoints      # 删除所有断点
(gdb) quit                    # 退出GDB

1
2
3
4
5
6

lldb ./bug_demo
(lldb) break set -n average
(lldb) run
(lldb) frame variable vals  # 显示局部变量
(lldb) thread info         # 当前线程信息
(lldb) process continue

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// .vscode/launch.json
{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "(gdb) Launch",
            "type": "cppdbg",
            "request": "launch",
            "program": "${workspaceFolder}/a.out",
            "args": [],
            "stopAtEntry": true,
            "cwd": "${workspaceFolder}",
            "environment": [],
            "externalConsole": false,
            "MIMode": "gdb",
            "preLaunchTask": "build"
        }
    ]
}

1
2
3
4
5

# 编译时启用ASan
g++ -fsanitize=address -g -O1 bug_demo.cpp -o bug_demo_asan

# 运行，ASan会自动检测内存错误
./bug_demo_asan

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

// asan_demo.cpp
#include <cstdlib>
#include <cstring>

void useAfterFree() {
    char* buf = new char[10];
    strcpy(buf, "hello");
    delete[] buf;
    // BUG: use after free
    char c = buf[0];  // ASan会在这里报错！
}

void heapOverflow() {
    char* buf = new char[10];
    // BUG: heap buffer overflow
    strcpy(buf, "this string is longer than 10 characters!");  // ASan会报错
    delete[] buf;
}

void stackOverflow() {
    char buf[10];
    // BUG: stack buffer overflow
    memset(buf, 'A', 100);  // 写到栈边界外了！
}

int main() {
    std::cout << "Testing ASan...\n";
    // 选择一个测试
    useAfterFree();
    // heapOverflow();
    // stackOverflow();
    return 0;
}

1
2

g++ -fsanitize=address -g -O1 asan_demo.cpp -o asan_demo
./asan_demo

1
2

# 在没有ASan的情况下使用Valgrind
valgrind --leak-check=full --show-leak-kinds=all ./bug_demo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// valgrind_demo.cpp
#include <stdlib.h>

void leakMemory() {
    void* p = malloc(100);
    // BUG: forgot to free(p)!
}

int main() {
    leakMemory();
    return 0;
}

1
2

g++ -g -O0 valgrind_demo.cpp -o valgrind_demo
valgrind --leak-check=full ./valgrind_demo

1
2

g++ -fsanitize=leak -g leak_demo.cpp -o leak_demo
./leak_demo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

// ubsan_demo.cpp
#include <cstdint>

int main() {
    // 有符号整数溢出 - UB！
    int x = INT_MAX;
    x = x + 1;  // UB: signed integer overflow

    // 空指针解引用
    int* p = nullptr;
    // int y = *p;  // UB: null pointer dereference

    // 数组越界访问
    int arr[5];
    // arr[10] = 0;  // UB: array out of bounds

    return 0;
}

1
2

g++ -fsanitize=undefined -g ubsan_demo.cpp -o ubsan_demo
./ubsan_demo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// tsan_demo.cpp
#include <thread>
#include <atomic>
#include <iostream>

// BUG: 数据竞争！
int counter = 0;  // 全局变量
std::mutex mtx;

void increment() {
    for (int i = 0; i < 100000; ++i) {
        // 没有锁保护的多线程写操作 - 数据竞争！
        counter++;  // 读-改-写操作，不是原子的！
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);
    t1.join();
    t2.join();
    // counter应该是200000，但很可能不是！
    std::cout << "Counter: " << counter << " (expected 200000)\n";
    return 0;
}

1
2

g++ -fsanitize=thread -g -O1 tsan_demo.cpp -lpthread -o tsan_demo
./tsan_demo

1
2
3
4
5
6
7
8

// 使用原子变量或互斥锁
std::atomic<int> counter(0);  // 原子类型

void increment() {
    for (int i = 0; i < 100000; ++i) {
        counter.fetch_add(1, std::memory_order_relaxed);  // 原子操作
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

// logger_demo.cpp
#include <iostream>
#include <fstream>
#include <sstream>
#include <chrono>
#include <iomanip>
#include <mutex>
#include <thread>

enum class LogLevel { DEBUG, INFO, WARNING, ERROR, FATAL };

class Logger {
public:
    static Logger& instance() {
        static Logger instance;
        return instance;
    }

    void setLevel(LogLevel level) { minLevel_ = level; }

    void log(LogLevel level, const std::string& file, int line, const std::string& msg) {
        if (level < minLevel_) return;

        std::lock_guard<std::mutex> lock(mutex_);
        auto now = std::chrono::system_clock::now();
        auto time = std::chrono::system_clock::to_time_t(now);
        auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
            now.time_since_epoch()) % 1000;

        std::cout << "[" << levelToString(level) << "] "
                  << std::put_time(std::localtime(&time), "%Y-%m-%d %H:%M:%S")
                  << "." << std::setfill('0') << std::setw(3) << ms.count()
                  << " [" << std::this_thread::get_id() << "] "
                  << file << ":" << line << " - " << msg << "\n";
    }

private:
    Logger() : minLevel_(LogLevel::DEBUG) {}

    std::string levelToString(LogLevel level) {
        switch (level) {
            case LogLevel::DEBUG: return "DEBUG";
            case LogLevel::INFO:  return "INFO ";
            case LogLevel::WARNING: return "WARN ";
            case LogLevel::ERROR: return "ERROR";
            case LogLevel::FATAL: return "FATAL";
        }
        return "UNKNOWN";
    }

    LogLevel minLevel_;
    std::mutex mutex_;
};

// 便捷宏
#define LOG_DEBUG(msg) Logger::instance().log(LogLevel::DEBUG, __FILE__, __LINE__, msg)
#define LOG_INFO(msg)  Logger::instance().log(LogLevel::INFO,  __FILE__, __LINE__, msg)
#define LOG_WARN(msg)  Logger::instance().log(LogLevel::WARNING, __FILE__, __LINE__, msg)
#define LOG_ERROR(msg) Logger::instance().log(LogLevel::ERROR, __FILE__, __LINE__, msg)
#define LOG_FATAL(msg) Logger::instance().log(LogLevel::FATAL, __FILE__, __LINE__, msg)

class NetworkManager {
public:
    bool connect(const std::string& host, int port) {
        LOG_INFO("Connecting to " + host + ":" + std::to_string(port));
        if (host.empty()) {
            LOG_ERROR("Host cannot be empty");
            return false;
        }
        // 模拟连接
        LOG_DEBUG("Connection established");
        return true;
    }

    bool send(const std::string& data) {
        if (data.empty()) {
            LOG_WARN("Sending empty data");
            return false;
        }
        LOG_DEBUG("Sent " + std::to_string(data.size()) + " bytes");
        return true;
    }
};

int main() {
    Logger::instance().setLevel(LogLevel::DEBUG);

    LOG_INFO("Application started");
    LOG_DEBUG("Debug mode enabled");

    NetworkManager net;
    net.connect("example.com", 8080);
    net.send("Hello, World!");
    net.connect("", 80);  // 会触发错误日志
    net.send("");         // 会触发警告日志

    LOG_INFO("Application finished");
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

#include <cassert>
#include <algorithm>

int binarySearch(const std::vector<int>& sorted, int target) {
    assert(std::is_sorted(sorted.begin(), sorted.end()) && 
           "binarySearch requires sorted input!");

    int left = 0, right = sorted.size() - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;  // 防止(left+right)溢出
        assert(mid >= 0 && mid < static_cast<int>(sorted.size()) &&
               "Mid index out of bounds - logic error!");
        if (sorted[mid] == target) return mid;
        if (sorted[mid] < target) left = mid + 1;
        else right = mid - 1;
    }
    return -1;
}

// 自定义断言宏（带上下文信息）
#define ASSERT_VECTOR_SIZE(v, expected_size) \
    assert((v).size() == (expected_size) && \
           "Vector size mismatch: " #v " has " \
           + std::to_string((v).size()) + " elements, expected " + #expected_size)

int main() {
    std::vector<int> nums{1, 3, 5, 7, 9};

    // NDEBUG定义时，assert失效
    // g++ -DNDEBUG program.cpp  # 禁用assert
    assert(binarySearch(nums, 5) == 2 && "5 should be at index 2");
    assert(binarySearch(nums, 6) == -1 && "6 not in array");

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// 错误：把用户输入验证写成assert
void processAge(int age) {
    assert(age >= 0);  // 错！年龄负数可能来自用户输入，应该返回错误
}

// 正确：区分断言和异常
void processAge(int age) {
    if (age < 0) {
        throw std::invalid_argument("Age cannot be negative");
    }
    assert(age <= 150);  // 对！如果年龄>150，肯定是程序bug（常量定义错了）
}