【C++17/20 constexpr新特性】:突破函数限制,实现真正的编译期执行

细聊Oracle通过ODBC数据源连接SQL Server数据库     类似文章搜索引擎上有很多,内容大致相同,今天所谓细聊是因为我在借鉴这些文章时候走了些弯路,所以写此文,为自己备忘,同时如果能为初涉此处知识点的小伙伴提供些帮助就更好了,废话不多说。    我的应用场景:    项目系统使用oracle数据库,与客户的第三方系统供应商实现资源共享,对方为sql server数据库;    我的测试开发环境为64bitwin7PC机,本机上装有64位Oracl... 阅读详情

第一章:C++ constexpr函数的核心概念与演进

constexpr函数的基本定义

constexpr 是 C++11 引入的关键字,用于声明在编译时可求值的常量表达式。当应用于函数时,它表示该函数在满足特定条件下可在编译期执行。一个 constexpr 函数可以接受编译时常量作为参数,并返回编译时常量,从而提升程序性能并支持模板元编程。

// 简单的 constexpr 函数示例:计算阶乘
constexpr int factorial(int n) {
    return (n <= 1) ? 1 : n * factorial(n - 1);
}

// 在编译期计算 factorial(5)
constexpr int result = factorial(5); // result = 120

上述代码中,factorial 函数被声明为 constexpr,只要传入的是编译时常量,调用结果也会在编译期完成计算,无需运行时开销。

从 C++11 到 C++20 的演进

C++ 标准对 constexpr 的支持逐步增强:

  • C++11:仅支持简单函数体,只能包含单条 return 语句
  • C++14:放宽限制,允许循环、局部变量和条件分支
  • C++20:引入 consteval 和更复杂的类型支持,如动态内存分配(受限)
标准版本constexpr 支持能力
C++11单一 return 语句,无循环或状态变量
C++14支持 for 循环、if 分支、局部变量
C++20支持类构造函数、lambda 表达式、有限堆操作

应用场景与优势

constexpr 函数广泛应用于编译期计算、模板参数生成、安全常量定义等场景。通过将计算提前到编译阶段,不仅减少了运行时负担,还增强了类型安全与代码可验证性。

第二章:C++17中constexpr的革命性扩展

2.1 允许局部变量与复合语句:编译期执行的基石

在现代编译器设计中,支持局部变量与复合语句是实现编译期执行(compile-time execution)的关键前提。这一机制使得编译器能够在不运行程序的情况下求值代码块,从而优化常量表达式、展开模板或执行元编程逻辑。
局部变量的作用域与生命周期
局部变量在复合语句块中定义,其作用域仅限于该块。这种受限可见性保证了编译期求值的安全性,避免副作用外泄。
复合语句的结构化执行
复合语句由一对花括号包裹,可包含多个声明与执行语句。编译器按顺序解析并评估其内部逻辑。

constexpr int compute() {
    int a = 5;
    int b = a * 2;
    { 
        int c = a + b; // 局部作用域变量
        return c;
    }
}
上述函数在编译期可完全求值:局部变量 a 和 b 被初始化后参与计算,嵌套复合语句中的变量 c 在作用域内完成加法运算并返回。整个过程无运行时依赖,体现了编译期执行的确定性与高效性。

2.2 支持try-catch异常处理:增强constexpr健壮性

C++20 标准首次允许在 `constexpr` 上下文中使用 `try-catch` 异常处理机制,显著提升了编译期计算的容错能力。
编译期异常处理示例
constexpr int safe_divide(int a, int b) {
    try {
        if (b == 0) throw "divide by zero";
        return a / b;
    } catch (...) {
        return -1;
    }
}
上述代码展示了在 `constexpr` 函数中捕获异常的能力。即使在编译期触发除零判断,也能通过 `catch` 块返回默认值,避免编译失败。
关键改进点
  • 异常路径可在编译期求值,提升逻辑完整性
  • 支持资源清理与错误恢复逻辑嵌入常量表达式
  • 增强了模板元编程中的错误诊断能力

2.3 更宽松的内存操作限制:动态行为的编译期模拟

在现代编译器优化中,放宽内存操作限制是提升性能的关键手段之一。通过在编译期对程序的动态行为进行建模,编译器能够在不改变语义的前提下重排内存访问指令。
编译期内存依赖分析
编译器利用静态分析识别内存读写之间的数据依赖关系,判断哪些操作可以安全重排序。例如:
int a, b;
void example() {
    a = 1;        // 写内存
    b = 2;        // 写内存,与上一条无依赖
}
上述代码中,对 a 和 b 的写入互不依赖,编译器可调整其执行顺序以优化流水线效率。
允许的优化策略对比
优化类型是否允许重排前提条件
独立读写是地址无关联
同地址写后读否必须保持顺序

2.4 实现编译期字符串处理:从理论到实践

在现代C++中,编译期字符串处理通过`constexpr`和模板元编程实现,允许在编译阶段完成字符串拼接、比较等操作,显著提升运行时性能。
核心机制:constexpr函数与模板递归
利用`constexpr`函数可让编译器在编译期求值。例如,构建一个编译期字符串长度计算:
constexpr int string_length(const char* str) {
    return *str ? 1 + string_length(str + 1) : 0;
}
该函数递归遍历字符指针,每层调用均为编译期常量表达式,最终结果直接嵌入二进制。
应用场景对比
场景运行时处理编译期处理
字符串校验延迟至运行时编译失败提前暴露错误
格式化字面量占用堆栈空间零开销抽象

2.5 利用if constexpr实现编译期分支优化

C++17 引入的 `if constexpr` 允许在编译期根据常量表达式条件选择性地实例化代码分支,从而消除运行时开销。
编译期条件判断机制
与传统 `if` 不同,`if constexpr` 在模板实例化时即完成分支裁剪,未满足条件的分支不会被生成到目标代码中。
template <typename T>
constexpr auto process(T value) {
    if constexpr (std::is_integral_v<T>) {
        return value * 2; // 整型:乘以2
    } else if constexpr (std::is_floating_point_v<T>) {
        return value + 1.0; // 浮点型:加1.0
    }
}
上述代码中,`if constexpr` 根据 `T` 的类型在编译期决定执行路径。例如传入 `int` 时,仅 `value * 2` 分支被保留,另一分支被静态排除,避免了运行时类型判断。
性能优势对比
  • 传统 `if`:所有分支参与编译,运行时判断
  • `if constexpr`:仅保留匹配分支,零运行时开销

第三章:C++20对constexpr的进一步深化

3.1 consteval与constinit关键字的精准控制

C++20引入的`consteval`和`constinit`为编译期计算与初始化提供了更精细的控制能力。
consteval:强制编译期求值
consteval int square(int n) {
    return n * n;
}
// constexpr int runtime = square(std::rand()); // 编译错误:非字面量参数
constexpr int compile_time = square(5); // 正确:编译期常量
`consteval`函数必须在编译期求值,任何运行时上下文调用都会触发编译错误,确保性能敏感代码路径的确定性。
constinit:保证静态初始化
该关键字确保变量使用常量初始化器进行初始化,避免静态构造顺序问题。
关键字作用目标核心约束
consteval函数、函数模板必须在编译期执行
constinit变量必须用常量表达式初始化

3.2 支持虚函数在constexpr上下文中的调用

C++20 起允许虚函数在 constexpr 上下文中调用,前提是编译时能确定具体调用的最终派生类函数。这一改进增强了编译期计算的能力。
语义约束
虚函数要参与 constexpr 计算,必须满足:
  • 函数本身被声明为 constexpr;
  • 调用上下文在编译期可求值;
  • 对象类型和虚函数目标在编译期已知。
代码示例
struct Base {
    virtual constexpr int value() const { return 10; }
};
struct Derived : Base {
    constexpr int value() const override { return 20; }
};

constexpr int foo() {
    Derived d;
    Base& b = d;
    return b.value(); // OK: 编译期可确定重写函数
}
上述代码中,尽管通过基类引用调用虚函数,但由于对象类型明确且所有函数均为 constexpr,编译器可在编译期完成解析与求值。

3.3 编译期内存分配:std::allocator的constexpr化

C++20 起,std::allocator 的部分接口支持 constexpr,使得内存分配行为可被推演至编译期,极大增强了元编程能力。
constexpr分配器的语义变化
传统动态内存分配无法在编译期求值,而通过 constexpr 化的分配器接口,可在常量表达式中构造容器模板实例,前提是不实际触发堆分配。
constexpr bool test_allocator() {
    std::allocator alloc;
    int* p = alloc.allocate(1);
    alloc.construct(p, 42);
    int val = *p;
    alloc.destroy(p);
    alloc.deallocate(p, 1);
    return val == 42;
}
static_assert(test_allocator()); // 编译期验证
上述代码展示了如何在 constexpr 函数中使用分配器完成内存申请与对象构造。尽管实际分配仍发生于运行时上下文,但整个逻辑路径可通过常量表达式验证,确保类型安全和接口正确性。
适用场景与限制
  • 适用于编译期已知大小的容器元编程场景
  • 不可用于真正持久化的堆内存操作
  • 需配合 std::array 或 std::span 实现零开销抽象

第四章:编译期计算的高级应用场景

4.1 编译期解析简单DSL:实现零运行时开销配置

在现代高性能系统中,配置解析的运行时开销常被忽视。通过编译期解析领域特定语言(DSL),可将配置检查与转换提前至构建阶段,实现零成本抽象。
DSL设计示例
采用类YAML语法描述服务配置:
//go:generate go run configgen.go
service api {
  port = 8080
  timeout_ms = 500
}
该DSL声明了服务名、端口和超时,无运行时反射解析。
代码生成流程
利用Go的//go:generate指令,在编译时生成类型安全的配置结构体:
type ServiceConfig struct {
    Port      int `json:"port"`
    TimeoutMs int `json:"timeout_ms"`
}
生成器解析AST并输出绑定代码,避免运行时解析负担。
优势对比
方案解析时机性能开销
JSON + 反射运行时高
编译期DSL编译时零

4.2 常量表达式与元编程结合:类型信息的静态构建

在现代C++中,常量表达式(`constexpr`)为元编程提供了强大的静态计算能力。通过将类型信息的构建过程前移至编译期,开发者能够实现高效且类型安全的抽象。
编译期类型特征提取
利用 `constexpr` 函数和模板特化,可在编译时判断并构造类型属性:
template <typename T>
constexpr bool is_integral_v = std::is_integral<T>::value;

template <typename T>
struct TypeInfo {
    static constexpr const char* category = 
        is_integral_v<T> ? "integral" : "other";
};
上述代码中,`TypeInfo::category` 在编译期即被确定为 `"integral"`,无需运行时开销。`constexpr` 确保了表达式的求值发生在编译阶段,提升了性能并支持后续模板决策。
静态类型注册表构建
结合 `constexpr` 与模板递归,可生成类型索引表:
TypeCategory
intintegral
doubleother

4.3 编译期数学运算库设计:高性能科学计算前置

在现代C++高性能计算中,编译期数学运算库通过 constexpr 与模板元编程实现零运行时开销的数值计算。这类库将常见数学函数(如三角函数、幂级数)的计算过程前移至编译阶段,显著提升执行效率。
核心设计原则
  • 使用 constexpr 函数保证编译期可求值
  • 递归模板展开实现循环逻辑(如泰勒级数逼近)
  • 类型安全封装,支持自定义精度策略
示例:编译期阶乘实现
template<int N>
struct Factorial {
    static constexpr int value = N * Factorial<N - 1>::value;
};

template<>
struct Factorial<0> {
    static constexpr int value = 1;
};
该模板通过特化终止递归,Factorial<5>::value 在编译时即被计算为 120,避免运行时重复计算。
性能对比
方法计算时机运行时开销
标准库函数运行期高
constexpr 实现编译期无

4.4 实现编译期容器:array与map的constexpr版本

在现代C++中,constexpr允许在编译期执行计算,为元编程提供了强大支持。通过实现编译期容器,可在编译阶段完成数据结构的构建与访问。
constexpr array 的实现要点
利用模板和递归,可构造可在编译期求值的数组:
template
struct constexpr_array {
    constexpr T& operator[](size_t i) { return data[i]; }
    constexpr const T& operator[](size_t i) const { return data[i]; }
    T data[N];
};
该结构体满足字面类型要求,所有操作在编译期完成。成员函数必须声明为 constexpr,确保参与常量表达式。
编译期 map 的键值映射机制
使用递归查找和std::integer_sequence,实现基于数组的 constexpr map:
  • 键值对在构造时初始化
  • 查找通过 constexpr 函数递归完成
  • 支持编译期断言验证存在性

第五章:未来展望与性能权衡分析

边缘计算与AI模型轻量化趋势
随着终端设备算力提升,将部分推理任务下沉至边缘节点成为优化延迟的关键路径。例如,在工业质检场景中,通过TensorRT对YOLOv5模型进行量化压缩,可在Jetson Xavier上实现83 FPS的实时检测。
  • 模型剪枝:移除冗余权重,降低参数量
  • 知识蒸馏:使用大模型指导小模型训练
  • 量化部署:FP32转INT8,减少内存带宽压力
异构计算资源调度策略
现代系统常融合CPU、GPU、NPU等多种计算单元。合理的任务分配需综合考虑能效比与响应延迟。以下为某视频处理流水线的资源分配示例:
处理阶段推荐硬件吞吐目标
帧预处理CPU + SIMD≥120 fps
目标检测GPU (CUDA)≥60 fps
行为识别NPU (TVM优化)≥30 fps
代码级性能调优实例
在Go语言实现的高并发日志处理器中,通过减少内存分配显著提升性能:

// 使用sync.Pool复用缓冲区
var bufferPool = sync.Pool{
    New: func() interface{} {
        return make([]byte, 0, 1024)
    },
}

func processLog(data []byte) {
    buf := bufferPool.Get().([]byte)
    defer bufferPool.Put(buf[:0]) // 归还前清空数据
    // 处理逻辑...
}
[输入流] → [解析器] → [过滤引擎] → [输出队列] ↓ ↑ [规则热加载] [指标上报]
霍尼韦尔SoftMaster使用说明 立即下载

相关推荐

STM32F4+FreeRTOS实战:手把手教你移植LWIP2.1.2(含LAN8720配置避坑指南)

本文提供了一份详尽的实战指南,手把手教你如何在STM32F4平台结合FreeRTOS实时操作系统,成功移植轻量级TCP/IP协议栈LWIP 2.1.2。文章重点剖析了硬件驱动层LAN8720 PHY芯片的配置要点与常见“坑点”,并深入讲解了LWIP与FreeRTOS的深度整合、关键配置及稳定性优化策略,旨在帮助开发者构建稳定可靠的产品级嵌入式网络功能。

ik678901234的博客 1065

C++ constexpr递归演进:从C++11到C++20的编译期计算实战

编译期计算是现代C++实现零成本抽象的核心技术之一,它允许在程序运行前完成计算,从而消除运行时开销并提前捕获错误。其原理是通过constexpr关键字标记函数或变量,使编译器能够在编译阶段执行求值。这项技术的价值在于提升程序性能、增强类型安全与确定性,广泛应用于数学常数计算、数据结构验证、配置解析等场景。随着C++标准的演进,constexpr能力不断扩展,从C++11的基础递归支持到C++20的动态内存分配,使得编译期编程更加灵活强大。本文聚焦constexpr递归的演化路径,结合json递归详解等实际案

weixin_34049948的博客 531

TIMER-XL:突破长上下文限制的Transformer时序预测新范式

本文深入解析了清华大学提出的TIMER-XL模型,这是一种突破长上下文限制的Transformer时序预测新范式。它采用Decoder-only架构与补丁级生成技术,并创新性地引入TimeAttention机制,有效解决了传统模型在处理海量历史数据时面临的“上下文瓶颈”问题,显著提升了长序列预测的精度与稳定性。

weixin_28340315的博客 447

《揭秘 constexpr:开启 C++编译期计算的神奇之旅》

我们可以创建一个模板化的数学库,其中的函数使用 constexpr 来实现,这样在编译使用这个数学库的代码时,编译器可以根据具体的类型和参数在编译期进行精确的计算和优化。想象一下,在编译代码的过程中,某些值就已经被确定了,这意味着在程序运行时,这些计算步骤完全可以省略,就像是提前准备好的礼物,在需要的时候直接拿出来用,大大节省了时间。我们需要深入理解它的本质、规则和应用场景,避开可能的陷阱,才能充分发挥它在编译期计算中的神奇作用,为我们的 C++编程之旅增添光彩,让我们的程序在性能的道路上一飞冲天。

xy520521的博客 770

PC网站实现微信扫码登录功能(二)

上篇我们介绍了怎么申请账号以及最后拿到appId和appSecret,如果有不清楚的可以看一下 PC网站实现微信扫码登录功能(一) 下面我就来说一下怎样在PC端怎么实现扫码登录功能。 一、进入官方文档网站 https://developers.weixin.qq.com/doc/oplatform/Website_App/WeChat_Login/Wechat_Login.html 其实官网对过程描述的已经非常细致了。并且提供了两种扫码方式。一种是跳转二维码扫描页面,另一种是内嵌式二维码。大家可以

qq_35771266的博客 3万+

28377D Bootloader

架构

a6100309120的博客 6016

【C++17 constexpr进阶指南】:嵌套条件编译的极致性能优化策略

掌握C++17 if constexpr 嵌套技巧,提升编译期性能优化能力。适用于模板元编程与多层条件判断场景,通过编译期分支剔除无效代码,显著减少运行时开销。详解语法要点与实战模式,值得收藏。

CodeWhim的博客 464

在linux上本地大模型部署与推理

您的Python脚本(客户端)可能在您的个人电脑上,而模型服务(服务器)在远程Linux服务器上。如果您的服务器有强大的NVIDIA GPU,并且您对性能有更高的要求(例如需要高吞吐量),vLLM是更好的选择。这种方式无需向公网暴露服务器端口,而是通过加密的SSH通道将服务器的端口“映射”到您的本地电脑上。我们将启动一个API服务器,它会加载您指定的模型,并等待您的代码前来调用。如果您直接在SSH窗口运行上面的命令,一旦您关闭窗口,服务就会停止。这是根据您的原始代码修改的版本,适配本地vLLM服务。

frostmelody 全网同名,大家多多关注呀~ 持续分享优质内容! 2063

深入理解constexpr递归(从C++11到C++20的深度演化)

掌握constexpr函数的递归深度控制技巧,提升编译期计算效率。详解从C++11到C++20中constexpr递归的演化过程,涵盖适用场景、限制突破与性能优化方法,实现更安全高效的元编程,值得收藏。

PixelGlow的博客 336

带你了解如何分析Jmeter监听器常用图表并定位瓶颈

1.1 Jmeter监听器常用图表 目录 1.1 Jmeter监听器常用图表 1.1-1 查看结果树 1.1-2 汇总报告 1.1-3 集合报告 1.1-4 综合图 1.1-5 断言结果 1.1-6 图形结果 1.1-7 响应时间图 1.2 Jmeter性能瓶颈定位 1.2-1 性能瓶颈产生的原因 1.2-2 性能瓶颈的解决方法 1.2-3 性能瓶颈如何定位 1.1-1 查看结果树 查看结果树:调试利器。可以查看每个请求具体的详情,方便进行测试的比对。有点类似我...

weixin_49029722的博客 4454

【深度学习新浪潮】Nano Banana(Gemini 2.5 Flash Image)技术解析与开发者实操指南

重新定义了 AI 图像生成的产业标准。它不仅是“平民化的视觉工厂”,更是推动内容生产从“创意试错”转向“精准制造”的关键工具。未来,随着视频生成能力的加入(谷歌计划支持“文字指令 - 动态场景 - 多平台适配”全流程),Nano Banana 有望进一步颠覆影视、广告等领域的创作范式。:批量生成多场景图,模特姿态自然,服装褶皱和材质细节高度一致,节省 90% 拍摄成本。模型的非正式代号,是一款革命性的 AI 图像生成与编辑工具,主打。:生成细节丰富的厨师特写,光影自然,皮肤纹理和刀具反光逼真。

专注:太空算力、AI infra、异构调度、大模型成本工程 895

C++26 constexpr重大突破:如何用constexpr实现编译期高性能计算?

掌握C++26 constexpr编译期计算新能力,提升系统性能与代码安全性。详解在模板元编程、容器操作与数学计算中的实用场景,结合2025全球C++及系统软件技术大会前沿分享,揭示高性能编译期优化核心方法。关键优势包括零运行时开销与类型安全,值得收藏。

VarPerch的博客 1040

12027.linux flash驱动之IS25LP01G/IS25WWP01G

一页:512字节 --> 扇区 4096字节 --> 块 32k,64k, 层层递进关系。

写给自己的笔记 2290

【C++】constexpr动态内存与双模式革命

摘要: constexpr是C++用于编译期计算的关键字,其演进从C++11到C++20逐步放宽限制。C++11引入基础功能但限制严格,仅支持单行表达式;C++14允许多语句和流程控制;C++17增加类支持、编译期条件分支;C++20实现突破性升级,支持动态内存分配和异常处理,使编译期与运行时代码几乎完全兼容。这一演进使constexpr从受限的编译期专用语法发展为功能完备的双模式编程工具。

Ape's IT Blog 1155

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

编译期计算:现代C++性能优化的新范式(从C++11到C++20的constexpr演进)

从C++11的初步引入,到C++20的全面赋能,constexpr经过多次迭代,早已从一个简单的“常量表达式标记”,成长为构建编译期计算体系的核心工具。本文将沿着C++标准的演进脉络,拆解constexpr的功能升级历程,剖析其底层实现的设计权衡,并结合实战案例,展示如何借助constexpr构建现代C++的性能优化新范式。

qq_40529346的博客 557

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

C++11 constexpr实战:从编译期计算到性能优化

本文深入探讨了C++11 constexpr关键字在编译期计算与性能优化中的实战应用。通过斐波那契数列、数学库查表等案例,展示了如何利用constexpr将运行时计算转移到编译期,提升程序性能。文章还详细解析了constexpr函数在不同C++标准中的演进,以及在类与对象、内存优化等场景中的精妙用法,为C++开发者提供了实用的性能优化方案。

java2000.net 405

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

C++编译期计算:从constexpr到consteval的演进与实战应用

编译期计算是现代编程语言中一项重要的优化技术,它允许在代码编译阶段完成计算任务,从而消除运行时开销。其核心原理是通过编译器在编译时执行特定代码逻辑,将计算结果直接嵌入最终的可执行文件中。这项技术的核心价值在于实现零开销抽象,提升程序性能,并增强类型安全。在C++中,编译期计算主要通过constexpr和consteval关键字实现,广泛应用于高性能计算、嵌入式系统、模板元编程等领域。随着C++标准的演进,特别是C++17引入的if constexpr和C++20的编译期容器支持,开发者现在能够以更直观的方式

weixin_32715349的博客 334

【C++20编译期编程突破】:constexpr构造函数初始化的5种高级用法

掌握C++ constexpr 构造函数的初始化技巧,提升编译期计算能力。涵盖字面量类型构造、模板元编程、数组预计算等5种高级用法,适用于高性能与零成本抽象场景。代码更安全高效,值得收藏。

CompiTide的博客 403

现代C++中constexpr递归深度突破技巧

例如计算超大阶乘时,先分解为若干子区间乘积,再合并结果,既保持编译期计算特性,又避免单次递归过深。而C++17的并行算法特性(如std::for_each(std::execution::par))虽主要针对运行时计算,但其分治思想可启发编译期递归优化——将大问题拆解为独立子任务,通过constexpr函数组合结果,从而规避单线程递归深度限制。在C++11阶段,constexpr函数被严格限制为仅包含单个return语句的常量表达式,且递归深度必须满足编译时可静态确定的条件,这导致复杂递归逻辑难以展开。

2501_93395238的博客 937

Day17-constexpr 进阶:编译期计算的艺术

C++进阶计划 · Day 17 | 预计学习时长:2小时。

如风逝去 284

C++ constexpr递归深度限制:5种算法优化技巧与实战指南

在C++现代编程中,编译期计算通过constexpr关键字将复杂计算从运行时移至编译期,从而提升程序性能、增强类型安全并优化嵌入式等场景的资源使用。其核心原理在于编译器在编译阶段对常量表达式进行求值,生成可直接使用的常量结果。这一技术价值显著,能够消除运行时开销,实现零成本抽象,广泛应用于数学库、模板元编程、领域特定语言(DSL)以及需要高性能计算的场景。然而,当开发者尝试使用constexpr实现递归算法时,常会遇到编译器设定的递归深度限制,这并非语言标准规定,而是编译器为防止无限递归或过度耗时编译而设置

weixin_33739541的博客 305

C++编译期计算与constexpr的进阶用法

template<size_t N, typename Key, typename Value> constexpr auto lookup_table = /* 编译期哈希表实现 */;

ydasw34623的博客 586

C++14到C++20中constexpr构造函数的演变(资深专家20年经验总结)

掌握constexpr构造函数的初始化技巧,提升C++程序编译期计算能力。本文梳理C++14到C++20中constexpr构造函数的演变,详解适用场景与核心实现方法,助力性能优化与类型安全,值得收藏。

VarFun的博客 359

Day25-编译期计算与 constexpr if:跨越编译与运行的边界

实践原因验证编译期计算编译期反馈错误,而不是运行时优先使用更清晰的代码,更好的错误信息限制递归深度防止编译器崩溃分离编译期/运行时计算查找表模式,性能最佳使用标准化的编译期常量表达避免过度元编程可读性优先,必要时使用宏。

如风逝去 211

C++11/14/17新特性解析

从C++11的constexpr函数到C++14的放松限制,再到C++17的if constexpr编译期条件判断,编译期计算能力持续增强。模板元编程与constexpr结合创造了新的编程范式,使程序在保持高性能的同时具备更强的表现力。类型推导体系的完善使C++在保持静态类型安全的同时,减少了冗余类型声明。variant和optional等类型安全容器的引入,减少了未定义行为的发生概率,提高了代码的健壮性。内联变量、改进的模板特性都为模块化编程打下基础,解决了头文件包含带来的编译延迟和依赖问题。

weixin_42383071的博客 896

C++27 constexpr支持动态内存分配与虚函数调用,编译期AI推理已成现实?

C++27 constexpr函数增强让编译期执行更强大:支持动态内存分配与虚函数调用, enabling 编译期AI模型推理、元编程优化与静态资源生成。显著提升构建时计算能力与类型安全,值得收藏。

Instrulink的博客 175
上一篇: C++高性能编程必知:alignas与alignof实战技巧(内存对齐全攻略)
下一篇: 揭秘C++20 <=>运算符:如何一键简化比较逻辑并避免常见陷阱
IterStream
博客等级 码龄1年 152粉丝 2112原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值