C++ Lambda表达式默认参数问题详解

原创 于 2025-12-13 00:15:00 发布 · 343 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++

C++ Lambda表达式默认参数问题详解

一、Lambda表达式默认参数的基本规则

1.1 Lambda默认参数的语法演变

// C++11：不支持默认参数
// auto lambda = [](int x = 10) { return x; };  // 编译错误！

// C++14：支持默认参数（但有限制）
auto lambda14 = [](int x = 10, int y = 20) {
    return x + y;
};

// C++17：改进默认参数支持
auto lambda17 = [](auto x = 10, auto y = 20.0) {
    return x + y;  // 返回double
};

// C++20：进一步扩展
auto lambda20 = []<typename T = int>(T x = 10) {
    return x * 2;
};

1.2 Lambda默认参数的特殊性

// Lambda的默认参数与普通函数不同
void regular_func(int x = 10) {}  // 声明处指定默认参数

// Lambda的默认参数必须在参数列表中直接指定
auto lambda = [](int x = 10) { return x; };

// 不能分开声明和定义
// auto lambda;  // 错误：lambda表达式不能只声明
// lambda = [](int x = 10) { return x; };  // 错误

// 默认参数不是lambda类型的一部分
auto lambda1 = [](int x = 10) { return x; };
auto lambda2 = [](int x = 20) { return x; };

// lambda1和lambda2的类型不同，即使只是默认参数不同
static_assert(!std::is_same_v<decltype(lambda1), decltype(lambda2)>);

二、Lambda默认参数的常见疑难问题

2.1 问题：默认参数与捕获列表的交互

问题现象：

// 尝试使用捕获的变量作为默认参数
int default_val = 42;

// 错误：默认参数不能引用捕获的变量
auto lambda = [default_val](int x = default_val) {
    // 编译错误：default_val不能作为默认参数
    return x;
};

// 尝试使用this指针的成员
class MyClass {
    int value = 100;
public:
    auto get_lambda() {
        // 错误：成员变量不能作为默认参数
        return [this](int x = this->value) { 
            return x;  // 编译错误
        };
    }
};

// 尝试使用局部变量
void test() {
    int local = 50;
    // 错误：默认参数必须是常量表达式或静态存储期变量
    auto lambda = [](int x = local) { return x; };  // 编译错误
}

解决方案：

// 方案1：使用重载（通过多个lambda模拟）
int default_val = 42;
auto lambda_without_arg = [default_val]() {
    return default_val;  // 使用捕获的值
};
auto lambda_with_arg = [](int x) {
    return x;
};

// 组合使用
auto call_lambda = [&](std::optional<int> arg = std::nullopt) {
    return arg ? lambda_with_arg(*arg) : lambda_without_arg();
};

// 方案2：使用std::function包装
std::function<int(int)> create_lambda(int default_value) {
    return [default_value](int x = default_value) -> int {
        // 注意：这里默认参数使用函数参数的拷贝
        return x;
    };
}

// 方案3：使用默认参数转发
auto make_lambda = [](int default_val) {
    // 返回一个lambda，其默认参数是固定的
    return [default_val](std::optional<int> arg = std::nullopt) {
        return arg.value_or(default_val);
    };
};

2.2 问题：默认参数与泛型Lambda

问题现象：

// C++14泛型lambda的默认参数问题
auto generic_lambda = [](auto x = 10) {
    return x;
};

// 问题1：默认参数类型推导
auto result1 = generic_lambda();    // x推导为int
auto result2 = generic_lambda(5.0); // x推导为double
// auto result3 = generic_lambda(); // 第二次调用，但x类型已固定为第一次推导？

// 问题2：实际上，每次调用都会重新推导
// 但默认参数类型由表达式10的类型决定

// 问题3：默认参数不一致
auto inconsistent = [](auto x = 10, auto y = 20.0) {
    return x + y;  // 可能产生意外的类型转换
};

auto r1 = inconsistent();      // x=int, y=double，返回double
auto r2 = inconsistent(5.0);   // x=double, y=double，返回double
auto r3 = inconsistent(5, 6);  // x=int, y=int，返回int

解决方案：

// 方案1：明确指定默认参数类型
auto safe_generic = []<typename T = int, typename U = double>(
    T x = T{10}, U y = U{20.0}) {
    // C++20模板lambda，可以明确控制类型
    return x + y;
};

// 方案2：使用type traits限制类型
auto constrained_lambda = [](auto x) {
    static_assert(std::is_arithmetic_v<decltype(x)>, 
                  "Argument must be arithmetic");
    return x * 2;
};

// 包装函数处理默认参数
auto make_constrained = [](auto default_value) {
    return [default_value](std::optional<decltype(default_value)> arg = std::nullopt) {
        auto value = arg.value_or(default_value);
        static_assert(std::is_arithmetic_v<decltype(value)>, 
                      "Value must be arithmetic");
        return value * 2;
    };
};

// 方案3：使用函数对象替代
struct GenericFunctor {
    template<typename T = int, typename U = double>
    auto operator()(T x = T{10}, U y = U{20.0}) const {
        return x + y;
    }
};

2.3 问题：默认参数在递归Lambda中的使用

问题现象：

// 递归lambda与默认参数的冲突
auto factorial = [](int n) {
    // 错误：lambda不能在自身内部引用自己
    if (n <= 1) return 1;
    return n * factorial(n - 1);  // 编译错误
};

// 使用std::function解决递归，但默认参数有问题
std::function<int(int, int)> recursive;
recursive = [&recursive](int n, int accumulator = 1) -> int {
    if (n <= 1) return accumulator;
    return recursive(n - 1, n * accumulator);
};

// 问题：默认参数只在顶层调用有效
int result = recursive(5);  // 使用默认参数accumulator=1
// 但递归调用中 accumulator 是显式传递的

// 另一个问题：lambda不能直接做递归调用
auto fib = [](int n, auto&& self) -> int {
    if (n <= 1) return n;
    return self(n - 1, self) + self(n - 2, self);
};

// 调用时需要使用Y组合子模式

解决方案：

// 方案1：使用函数对象
struct Factorial {
    int operator()(int n, int accumulator = 1) const {
        if (n <= 1) return accumulator;
        return (*this)(n - 1, n * accumulator);  // 正确递归
    }
};

// 方案2：使用std::function + 包装函数
auto make_recursive = []() {
    std::function<int(int, int)> impl;
    impl = [&impl](int n, int accumulator = 1) -> int {
        if (n <= 1) return accumulator;
        return impl(n - 1, n * accumulator);
    };
    return [impl](int n) { return impl(n); };  // 封装默认参数
};

// 方案3：C++23 deducing this简化递归
#if __cplusplus > 202002L
auto modern_factorial = [](this auto&& self, int n, int accumulator = 1) -> int {
    if (n <= 1) return accumulator;
    return self(n - 1, n * accumulator);
};
#endif

// 方案4：使用Y组合子
template<typename F>
struct YCombinator {
    F f;
    template<typename... Args>
    decltype(auto) operator()(Args&&... args) const {
        return f(*this, std::forward<Args>(args)...);
    }
};

auto factorial_y = YCombinator{
    [](auto&& self, int n, int accumulator = 1) -> int {
        if (n <= 1) return accumulator;
        return self(n - 1, n * accumulator);
    }
};

2.4 问题：默认参数与可变参数模板Lambda

问题现象：

// 可变参数lambda与默认参数的结合
auto varargs_lambda = [](auto... args) {
    // 无法为可变参数指定默认值
    return sizeof...(args);
};

// 尝试混合固定参数和可变参数
auto mixed = [](int x = 10, auto... rest) {
    // 问题：rest能否有默认值？
    return x + sizeof...(rest);
};

// 实际使用中的歧义
auto result1 = mixed();      // x=10, rest为空
auto result2 = mixed(20);    // x=20, rest为空
// auto result3 = mixed(, 1, 2);  // 错误：语法不支持

// C++20模板lambda的类似问题
auto template_lambda = []<typename... Ts>(Ts... args) {
    // 同样无法为模板参数包指定默认值
};

解决方案：

// 方案1：使用重载模式（多个lambda）
auto lambda0 = []() { return 10 + 0; };
auto lambda1 = [](int x) { return x + 0; };
auto lambda2 = [](int x, auto y) { return x + 1; };

// 方案2：使用参数包装
struct Params {
    int x = 10;
    std::vector<int> rest;
};

auto param_lambda = [](const Params& p = {}) {
    int sum = p.x;
    for (int v : p.rest) sum += v;
    return sum;
};

// 方案3：使用std::optional或variant处理可选参数
auto flexible_lambda = [](std::optional<int> x = std::nullopt,
                          std::vector<int> rest = {}) {
    int x_val = x.value_or(10);
    int sum = x_val;
    for (int v : rest) sum += v;
    return sum;
};

// 方案4：使用tuple打包参数
auto tuple_lambda = [](std::tuple<int, std::vector<int>> args = {10, {}}) {
    auto [x, rest] = args;
    int sum = x;
    for (int v : rest) sum += v;
    return sum;
};

// 方案5：命名参数模式（使用结构化绑定）
auto named_param_lambda = [](auto&&... args) {
    // 解析命名参数
    int x = 10;
    std::vector<int> rest;
    
    // 使用折叠表达式处理命名参数
    ([&](auto arg) {
        if constexpr (std::is_same_v<decltype(arg), int>) {
            x = arg;
        } else if constexpr (std::is_same_v<decltype(arg), std::vector<int>>) {
            rest = arg;
        }
    }(args), ...);
    
    return x + std::accumulate(rest.begin(), rest.end(), 0);
};

三、Lambda默认参数的存储和生命周期问题

3.1 默认参数值的存储位置

// 默认参数值存储在哪里？
int global_default = 100;

auto lambda1 = [](int x = global_default) {
    return x;
};

// 修改全局变量
global_default = 200;
auto result1 = lambda1();  // 返回200，使用调用时的global_default

// 使用字面量
auto lambda2 = [](int x = 100) {
    return x;
};
// 字面量100嵌入在lambda的类型信息中

// 使用局部静态变量
auto create_lambda = []() {
    static int static_default = 300;
    return [](int x = static_default) { return x; };
};

auto lambda3 = create_lambda();
// 注意：所有lambda共享同一个static_default

3.2 默认参数与lambda的捕获

// 默认参数值是否参与捕获？
int external = 10;

auto lambda = [external](int x = external) {
    // 这里有两个external：
    // 1. 捕获的external（lambda对象的成员）
    // 2. 默认参数中的external（外部变量）
    return x;
};

external = 20;
auto result = lambda();  // 返回20，使用外部变量，而不是捕获的值

// 证明：默认参数不参与值捕获
auto capturing_lambda = [external](int x = external) {
    return std::pair{external, x};  // 第一个是捕获的值，第二个是默认参数
};

external = 30;
auto [captured, arg] = capturing_lambda();
// captured = 10（捕获时的值）
// arg = 30（调用时默认参数的值）

四、调试和诊断工具

4.1 编译时检查默认参数

#include <type_traits>
#include <iostream>

// 检查lambda是否接受特定数量的参数
template<typename Lambda, typename... Args>
constexpr bool accepts_args(Lambda&&, Args&&...) {
    return std::is_invocable_v<Lambda, Args...>;
}

// 测试默认参数
void test_default_args() {
    auto lambda = [](int x = 10, int y = 20) { return x + y; };
    
    // 检查不同调用方式
    static_assert(accepts_args(lambda, 1, 2), "Should accept 2 args");
    static_assert(accepts_args(lambda, 1), "Should accept 1 arg with default");
    static_assert(accepts_args(lambda), "Should accept 0 args with defaults");
    
    // 打印类型信息
    std::cout << "Lambda type: " << typeid(lambda).name() << std::endl;
}

// 默认参数值检查
template<auto Lambda, typename... Args>
constexpr auto get_default_result() {
    if constexpr (std::is_invocable_v<decltype(Lambda), Args...>) {
        return std::invoke(Lambda, Args{}...);
    } else {
        return nullptr;
    }
}

4.2 运行时调试支持

// Lambda调试包装器
template<typename Lambda>
class DebugLambda {
    Lambda lambda;
    std::string name;
    
public:
    DebugLambda(Lambda l, std::string n = "lambda") 
        : lambda(std::move(l)), name(std::move(n)) {}
    
    template<typename... Args>
    auto operator()(Args&&... args) const {
        std::cout << "Calling " << name << " with " 
                  << sizeof...(args) << " arguments\n";
        
        // 记录默认参数的使用
        if constexpr (sizeof...(args) == 0) {
            std::cout << "Using default parameters\n";
        }
        
        auto result = lambda(std::forward<Args>(args)...);
        std::cout << "Result: " << result << std::endl;
        return result;
    }
};

// 使用示例
auto create_debug_lambda = [](auto lambda, std::string name = "") {
    return DebugLambda<decltype(lambda)>(std::move(lambda), name);
};

void test_debug() {
    auto lambda = create_debug_lambda(
        [](int x = 10, int y = 20) { return x + y; },
        "adder"
    );
    
    lambda();      // 输出：使用默认参数
    lambda(5);     // 输出：传递1个参数
    lambda(1, 2);  // 输出：传递2个参数
}

五、现代C++中的替代方案

5.1 使用函数对象替代

// 函数对象提供更好的默认参数控制
struct ConfigurableFunctor {
    int default_x;
    int default_y;
    
    ConfigurableFunctor(int x = 10, int y = 20) 
        : default_x(x), default_y(y) {}
    
    // 可以有多个operator()重载
    int operator()() const { return default_x + default_y; }
    int operator()(int x) const { return x + default_y; }
    int operator()(int x, int y) const { return x + y; }
    
    // 可变参数版本
    template<typename... Args>
    auto operator()(Args... args) const {
        return (... + args);  // C++17折叠表达式
    }
};

// 使用
ConfigurableFunctor func;
auto result1 = func();      // 10 + 20 = 30
auto result2 = func(5);     // 5 + 20 = 25
auto result3 = func(1, 2);  // 1 + 2 = 3

5.2 使用std::bind部分应用

#include <functional>

// std::bind可以创建带默认参数的函数对象
auto base_lambda = [](int x, int y, int z) { return x + y + z; };

// 绑定部分参数
auto bound1 = std::bind(base_lambda, 10, std::placeholders::_1, 20);
auto result1 = bound1(5);  // 10 + 5 + 20 = 35

// 绑定所有参数（创建无参数调用）
auto bound2 = std::bind(base_lambda, 1, 2, 3);
auto result2 = bound2();  // 1 + 2 + 3 = 6

5.3 C++20简化方案

// C++20：使用concepts约束泛型lambda
auto constrained_lambda = []<std::integral T = int>(
    T x = T{10}, T y = T{20}) -> T {
    return x + y;
};

// C++20：模板lambda支持更复杂的默认值
auto factory_lambda = []<typename T = std::vector<int>>(
    std::size_t size = 10, const typename T::value_type& value = {}) {
    return T(size, value);
};

// 使用
auto vec1 = factory_lambda();              // vector<int>(10, 0)
auto vec2 = factory_lambda(5, 42);         // vector<int>(5, 42)
auto vec3 = factory_lambda.operator()<std::vector<double>>(3, 3.14);

六、最佳实践总结

6.1 何时使用Lambda默认参数

// 适合场景1：简单、固定的默认值
auto simple = [](int timeout = 1000) {
    // 简单的超时设置
    return process_with_timeout(timeout);
};

// 适合场景2：配置对象参数
struct Config { int threads = 4; bool debug = false; };
auto worker = [](Config config = {}) {
    // 使用配置对象的默认值
    return create_worker(config);
};

// 适合场景3：算法参数
auto algorithm = [](double tolerance = 1e-6, int max_iter = 1000) {
    return run_algorithm(tolerance, max_iter);
};

6.2 何时避免Lambda默认参数

// 避免场景1：需要运行时计算的默认值
// 错误示例
int compute_default() { return rand(); }
auto bad_lambda = [](int x = compute_default()) { return x; };
// 问题：compute_default()在编译时求值

// 正确做法
auto good_lambda = [](std::optional<int> x = std::nullopt) {
    return x.value_or(compute_default());
};

// 避免场景2：依赖捕获变量的默认值
int external = 10;
auto dangerous = [external](int x = external) {
    // 默认参数使用外部变量，捕获使用值
    // 容易混淆
    return x + external;
};

// 避免场景3：复杂的泛型默认参数
auto too_complex = [](auto x = std::vector{1, 2, 3}) {
    // 类型推导可能不明确
    return x.size();
};

// 正确：明确类型
auto clear = []<typename T = std::vector<int>>(
    const T& x = T{1, 2, 3}) {
    return x.size();
};

6.3 设计建议

// 建议1：保持默认参数简单
auto recommended1 = [](int retries = 3, double factor = 1.5) {
    // 使用明确的字面量或简单表达式
    return calculate(retries, factor);
};

// 建议2：使用结构体包装多个参数
struct SearchParams {
    std::string query;
    int limit = 10;
    bool case_sensitive = false;
};

auto search = [](SearchParams params = {}) {
    // 清晰的参数结构
    return perform_search(params);
};

// 建议3：考虑使用生成器函数
auto make_lambda_with_defaults = [](int default_x, int default_y) {
    // 返回配置好的lambda
    return [default_x, default_y](int x = default_x, int y = default_y) {
        return x + y;
    };
};

// 建议4：文档化默认参数行为
/**
 * @brief Lambda with configurable defaults
 * @param x First parameter (default: 10)
 * @param y Second parameter (default: 20)
 * @return Sum of x and y
 */
auto documented_lambda = [](int x = 10, int y = 20) -> int {
    return x + y;
};

七、总结

Lambda表达式默认参数是现代C++中强大但需要谨慎使用的特性：

关键要点：

  1. C++14开始支持：但功能有限，C++17/C++20有改进
  2. 默认参数不参与捕获：使用外部变量的当前值
  3. 类型推导需谨慎：特别是泛型lambda中的默认参数
  4. 递归lambda需特殊处理：不能直接在自身内使用默认参数
  5. 生命周期问题：默认参数值在调用时求值

最佳实践：

  • 保持默认参数简单、明确
  • 避免使用捕获变量作为默认参数
  • 对于复杂场景，考虑使用函数对象或结构体参数
  • 泛型lambda中明确指定默认参数类型
  • 使用现代C++特性（C++20概念、模板lambda等）提高安全性

调试建议：

  • 使用static_assert检查调用有效性
  • 使用包装器记录调用信息
  • 明确文档化默认参数的行为和限制

掌握这些知识后，可以在保持代码简洁性的同时，避免Lambda默认参数带来的常见陷阱。

C++ lambda表达式详解
Solititude的博客
05-16 945
C++ lambda表达式详解
C++ Lambda表达式详解
热门推荐
一起加油~
05-07 8万+
Lambda表达式概述 Lambda表达式是现代C++在C ++ 11和更高版本中的一个新的语法糖 ，在C++11、C++14、C++17和C++20中Lambda表达的内容还在不断更新。 lambda表达式（也称为lambda函数）是在调用或作为函数参数传递的位置处定义匿名函数对象的便捷方法。通常，lambda用于封装传递给算法或异步方法的几行代码 。本文主要介绍Lambda的工作原理以及使用方法。 Lambda表达式定义 Lambda表达式示例 Lambda有很多叫法，有Lambda表达式、Lambda
C++ Lambda表达式应用详解
半青年的博客
05-09 663
Lambda表达式通过简化函数对象的定义，显著提升了代码的简洁性与可维护性。其在STL算法、事件回调、闭包管理等场景中表现尤为突出。开发者需熟练掌握捕获机制与生命周期管理，避免潜在陷阱。随着C++标准的演进（如C++20引入模式匹配），Lambda的应用将进一步扩展，成为现代C++开发的核心工具之一。
c++中的Lambda表达式详解
cyz322649的博客
08-14 1636
摘要： C++11引入的Lambda表达式是一种匿名函数对象，极大简化了代码编写。其语法为捕获列表->返回类型{函数体}，其中捕获列表决定对外部变量的访问方式（值捕获、引用捕获等）。Lambda广泛应用于STL算法（如sort、for_each）、异步编程（std::thread）、回调函数等场景，提升代码局部性和可读性。返回值可通过显式声明或编译器自动推导处理。Lambda支持赋值给变量（推荐auto或std::function），便于复用和传递，同时避免命名污染。结合捕获能力与函数式特性，Lamb
【C++】 Lambda表达式详解
kinghzking的专栏
06-09 4214
仿函数的语法几乎和我们普通的函数调用一样，不过作为仿函数的类，都必须重载operator()运算符，仿函数与Lamdba表达式的作用是一致的。如果Lambda表达式的函数体只有一条语句，且该语句的返回值类型可以自动推导，则可以省略返回值类型和return关键字。记得去年立了一个重学C++新特性的flag，可是真的太忙了，大部分精力都花在全栈上了，今年开始看一些开源源码，发现各种奇怪的语法，根本看不懂，，它可以方便地定义一个匿名函数，从而简化代码的编写。，可以像函数一样被调用，也可以作为函数参数或返回值。
C++ Lambda 表达式详解
weixin_40026739的博客
03-13 1331
Lambda 表达式是 C++11 引入的匿名函数对象，用于简化代码逻辑的封装，尤其在需要临时函数或回调的场景中非常实用。：基础功能在 C++11 中引入，泛型 Lambda（C++14）、模板 Lambda（C++20）逐步增强。通过合理使用 Lambda，可以显著提升代码的可读性和简洁性，但需注意捕获安全和生命周期管理。：按引用捕获局部变量时，确保 Lambda 生命周期不超过变量。默认情况下，按值捕获的变量在 Lambda 内不可修改。：指定外部变量的捕获方式（按值、按引用等）。
【C++】 Lambda 表达式详解
浩瀚之水的专栏
04-12 1262
Lambda 表达式是 C++11 引入的匿名函数对象，用于简化代码、支持函数式编程风格，并替代传统函数对象（如仿函数）。其核心功能是在作用域内捕获变量，并定义轻量级的局部函数逻辑。
【C++11】lambda表达式详解
平淡中造就不平凡
07-18 757
Lambda表达式是现代C++在C ++ 11和更高版本中的一个新的语法糖 ，在C++11、C++14、C++17和C++20中Lambda表达的内容还在不断更新。Lambda表达式（外文名：lambda expression）是一个匿名函数，即没有函数名的函数。
C++中的Lambda表达式详解
YRB0127的博客
08-19 1226
Lambda表达式，也称为匿名函数，是一种可以在函数内部或其他任何地方定义的未命名函数。它允许你在需要函数的地方直接定义一个函数，而不必先在其他地方声明和定义。在算法函数（如std::sort等）中传递自定义的操作。定义一次性使用的小型函数，避免为简单的操作单独定义函数。在并发编程中传递函数对象。Lambda表达式为C++引入了强大的匿名函数功能，使得代码更加简洁、高效。
精选资源
C++ Lambda表达式使用详解
01-20
　对于一次性的，带参数表达式，用LB可以节省不必要的class定义和维护，简化程序的设计-维护代价。 　比如下面的vector处理代码，简洁明了： 　vector<int> v1(10， 1); 　int sum = 0; 　for_each (v1.begin()...
Qt C++ 多线程网络请求落地指南：解决卡顿与数据同步痛点
2202_75382767的博客
12-08 935
本文介绍了Qt多线程网络请求的实现方案，解决主线程卡顿和数据同步问题。核心方案是将网络请求移至子线程处理，通过信号槽与主线程通信。文章详细剖析了卡顿根源，并提供了基础实现代码，包括封装网络请求工作类和使用QThread管理子线程。该方案遵循Qt线程安全原则，确保UI流畅性和数据正确性。
C++ -- 哈希表
最新发布
2301_80059080的博客
12-12 1239
本文系统介绍了哈希表的核心概念与实现方法。首先阐述了哈希的基本思想：通过哈希函数建立键值与存储位置的映射关系，实现O(1)时间复杂度的操作。然后详细讲解了哈希函数设计（包括除法散列法、乘法散列法等）和冲突处理策略，重点分析了开放定址法（线性探测、二次探测、双重散列）和链地址法两种主要冲突解决方案。文章还提供了完整的C++实现代码，包括哈希表结构设计、扩容机制、插入/查找/删除操作等关键算法，并通过示例演示了哈希表的工作过程。最后比较了不同方法的优缺点，指出链地址法在实践中的优势。
【MCAL】CCFC3008PC-EB配置之SPI
wwjh_go的博客
12-11 540
摘要：本文介绍了DSPI(反序列化串行外设接口)的配置与应用。系统包含7个DSPI模块，实际使用了DSPI1和DSPI2两个模块。重点阐述了SPI通信的基本单元结构：Job(完整通信)、Channel(数据装载)和Sequence(操作序列)的关系。详细说明了SPI的配置流程，包括通道、任务、序列、硬件和外设等设置。最后通过工程测试验证了SPI通信功能，展示了片选信号、时钟信号以及MOSI/MISO数据线的波形图。测试结果表明系统实现了预期的SPI数据传输功能。
C++ 日志实现
weixin_42252757的博客
12-11 150
【代码】C++ 日志实现。
C++从入门到入土 （1）：C++入门基础
ZCollapsar的博客
12-09 790
1.定义命名空间，需要使用到 namespace 关键字，后面跟命名空间的名字，然后接一对{ }即可，{ } 中即为命名空间的成员。命名空间中可以定义变量/函数/类型等。2.namespace本质是定义出一个域，这个域跟全局域各自独立，不同的域可以定义同名变量，所以下面的 rand 不在冲突了。3.C++中域有函数局部域，全局域，命名空间域，类域。4.域影响的是编译时语法查找一个变量/函数类型出处（声明或定义）的逻辑，所以有了域隔离，名字冲突就解决了。
使用 C++ 实现高性能定时任务调度器——Timer Wheel + 线程池
XXYBMOOO的博客
12-12 592
时间轮（Timer Wheel）是一种高效管理定时任务的数据结构，它将时间划分为若干个固定间隔的“槽”（slot），每个槽对应一个时间段。当时间轮转动时，轮到某个槽，槽内的任务就到期执行。相比于传统的优先队列或链表调度，时间轮在任务数量极多时可以显著降低时间复杂度，从而提高性能。时间复杂度接近 O(1)支持大规模任务易于结合线程池实现并发执行本文介绍了基于时间轮 + 线程池的高性能定时任务调度器TimerWheel，适用于工业采集、物联网和高并发服务端场景。任务调度延迟低支持大规模任务。
C++ Lambda表达式核心用法与实战详解
C++ Lambda表达式的完整形式由六个部分组成：捕获列表（capture list）、参数列表（parameter list）、可变规范（mutable specifier）、异常说明（exception specification）、返回类型（return type）以及函数体...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值