测试_第05章_函数与lambda.cpp

← 测试总览 · 目录

编译运行：clang++ -std=c++26 -Wall -Wextra -pthread 测试_第05章_函数与lambda.cpp -o t && ./t（需先 cd 测试/）

// 第5章测试：函数与 lambda
#include <print>
#include <string>
#include <vector>
#include <algorithm>

int failures = 0;
#define CHECK(expr)                                                         \
    do {                                                                    \
        if (!(expr)) {                                                      \
            ++failures;                                                     \
            std::println("FAIL 第{}行: {}", __LINE__, #expr);              \
        }                                                                   \
    } while (0)

// 5.3 三种传参方式（by_value 里故意修改参数以演示"外面不变"）
void by_value(int x) { x = 999; (void)x; }
void by_ref(int& x) { x = 999; }
std::string by_const_ref(const std::string& s) { return s; }
static void mark_value([[maybe_unused]] int) {}

// 5.4 默认参数
std::string greet(std::string name, std::string greeting = "你好") {
    return greeting + ", " + name;
}

// 5.5 重载
int max_of(int a, int b) { return a > b ? a : b; }
double max_of(double a, double b) { return a > b ? a : b; }
int max_of(int a, int b, int c) { return max_of(max_of(a, b), c); }

// 5.10 返回局部对象（按值，安全）
std::string make_big_string() { return std::string(1000, 'x'); }

int main() {
    // 5.1/5.2 基本函数
    auto add = [](int a, int b) { return a + b; };
    CHECK(add(3, 5) == 8);
    mark_value(0);

    // 5.3 传值 vs 传引用
    int a = 1;
    by_value(a);
    CHECK(a == 1);                                      // 传值：外面不变
    by_ref(a);
    CHECK(a == 999);                                    // 传引用：外面变
    CHECK(by_const_ref("hi") == "hi");

    // 5.4 默认参数
    CHECK(greet("小明") == "你好, 小明");
    CHECK(greet("小明", "早上好") == "早上好, 小明");

    // 5.5 重载
    CHECK(max_of(3, 7) == 7);
    CHECK(max_of(3.5, 2.1) == 3.5);
    CHECK(max_of(1, 2, 3) == 3);

    // 5.6 lambda 基本
    auto f = [](int x) { return x * 2; };
    CHECK(f(21) == 42);

    // 5.7 捕获：按值 vs 按引用
    int offset = 10;
    auto cap_v = [offset] { return offset; };           // 按值
    auto cap_r = [&offset] { return offset; };          // 按引用
    offset = 20;
    CHECK(cap_v() == 10);                               // 按值：快照
    CHECK(cap_r() == 20);                               // 按引用：看最新

    // 初始化捕获 C++14
    auto init = [y = offset * 2] { return y; };
    CHECK(init() == 40);

    // 5.8 泛型 lambda C++14
    auto gadd = [](auto a, auto b) { return a + b; };
    CHECK(gadd(1, 2) == 3);
    CHECK(gadd(1.5, 2.5) == 4.0);
    CHECK(gadd(std::string("a"), std::string("b")) == "ab");

    // 5.9 lambda 传给算法
    std::vector<int> v{5, 1, 4, 2, 3};
    std::sort(v.begin(), v.end(), [](int x, int y) { return x > y; });
    CHECK(v[0] == 5 && v[4] == 1);

    // 5.10 返回局部对象按值安全
    std::string big = make_big_string();
    CHECK(big.size() == 1000);

    if (failures == 0) std::println("全部通过");
    return failures;
}