Rust 模块系统与可见性控制实战:构建清晰的代码结构

【Rust 精进之路之30篇 - 模块化】包、Crate 与模块系统:大型项目的组织结构 Rust 的模块系统(包、Crate、模块、路径、usepub)提供了一套强大而灵活的工具来组织代码、控制可见性和封装实现细节。Cargo 管理的基本单元,包含Cargo.toml和源代码。编译单元,可以是库 (lib.rs) 或二进制 (main.rsbin/*.rs模块 (mod在 Crate 内部组织代码,形成命名空间和层级结构,可放在单独文件。用于引用项,分绝对路径 (crate::...) 和相对路径 (可见性 (pub默认私有,使用pub使项对外部可见。结构体字段可见性需单独指定。 阅读详情

Rust 模块系统与可见性控制实战:构建清晰的代码结构

模块系统的重要性

在大型项目中,良好的代码组织是非常重要的。Rust的模块系统提供了一种结构化的方式来组织代码,使得代码更加清晰、可维护,并且可以控制代码的可见性。通过合理使用模块系统,我们可以构建更加模块化、可重用的代码。

基本概念

模块

模块是Rust中代码组织的基本单位,它可以包含函数、结构体、枚举、常量等。

// src/lib.rs
mod utils {
    pub fn add(a: i32, b: i32) -> i32 {
        a + b
    }
}

pub fn greet() {
    println!("Hello, world!");
}

可见性控制

Rust使用关键字来控制代码的可见性:

  • pub:公开的,可以被其他模块访问
  • 默认(无关键字):私有的,只能在当前模块及其子模块中访问
  • pub(crate):在当前 crate 中可见
  • pub(super):在父模块中可见
  • pub(in path):在指定路径的模块中可见

模块的创建和使用

单文件模块

// src/main.rs
mod math {
    pub mod arithmetic {
        pub fn add(a: i32, b: i32) -> i32 {
            a + b
        }
        
        pub fn subtract(a: i32, b: i32) -> i32 {
            a - b
        }
    }
    
    pub mod geometry {
        pub fn area(width: f64, height: f64) -> f64 {
            width * height
        }
    }
}

fn main() {
    let sum = math::arithmetic::add(1, 2);
    println!("1 + 2 = {}", sum);
    
    let area = math::geometry::area(2.0, 3.0);
    println!("面积: {}", area);
}

多文件模块

// 目录结构
// src/
// ├── main.rs
// ├── math/
// │   ├── mod.rs
// │   ├── arithmetic.rs
// │   └── geometry.rs
// src/math/mod.rs
pub mod arithmetic;
pub mod geometry;
// src/math/arithmetic.rs
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}
// src/math/geometry.rs
pub fn area(width: f64, height: f64) -> f64 {
    width * height
}
// src/main.rs
mod math;

fn main() {
    let sum = math::arithmetic::add(1, 2);
    println!("1 + 2 = {}", sum);
    
    let area = math::geometry::area(2.0, 3.0);
    println!("面积: {}", area);
}

可见性控制的使用

基本可见性

mod outer {
    pub fn outer_public() {
        println!("外部模块的公开函数");
        inner::inner_private(); // 可以访问子模块的私有函数
    }
    
    fn outer_private() {
        println!("外部模块的私有函数");
    }
    
    mod inner {
        pub fn inner_public() {
            println!("内部模块的公开函数");
            super::outer_private(); // 可以访问父模块的私有函数
        }
        
        fn inner_private() {
            println!("内部模块的私有函数");
        }
    }
}

fn main() {
    outer::outer_public(); // 可以访问外部模块的公开函数
    // outer::outer_private(); // 不能访问外部模块的私有函数
    // outer::inner::inner_public(); // 不能访问内部模块的公开函数
}

高级可见性

mod crate_level {
    pub(crate) fn crate_public() {
        println!("整个crate可见的函数");
    }
    
    fn crate_private() {
        println!("crate内私有的函数");
    }
    
    mod module_level {
        pub(in crate::crate_level) fn module_public() {
            println!("在指定模块内可见的函数");
            super::crate_private(); // 可以访问父模块的私有函数
        }
        
        fn module_private() {
            println!("模块内私有的函数");
        }
    }
}

fn main() {
    crate_level::crate_public(); // 可以访问整个crate可见的函数
    // crate_level::crate_private(); // 不能访问crate内私有的函数
    // crate_level::module_level::module_public(); // 不能访问指定模块内可见的函数
}

模块的组织方式

分层组织

// 典型的Rust项目结构
// my_project/
// ├── Cargo.toml
// └── src/
//     ├── main.rs        // 可执行文件入口
//     ├── lib.rs         // 库文件入口
//     ├── models/        // 数据模型
//     │   ├── mod.rs
//     │   ├── user.rs
//     │   └── post.rs
//     ├── controllers/   // 控制器
//     │   ├── mod.rs
//     │   ├── user_controller.rs
//     │   └── post_controller.rs
//     ├── services/      // 业务逻辑
//     │   ├── mod.rs
//     │   ├── user_service.rs
//     │   └── post_service.rs
//     └── utils/         // 工具函数
//         ├── mod.rs
//         └── helper.rs

模块的导入

// 使用use关键字导入模块
use crate::models::user::User;
use crate::services::user_service::{create_user, get_user};

fn main() {
    let user = User { id: 1, name: "Alice".to_string() };
    create_user(&user);
    let fetched_user = get_user(1);
    println!("用户: {:?}", fetched_user);
}

模块的重导出

// src/models/mod.rs
pub mod user;
pub mod post;

// 重导出,使得外部可以直接通过models::User访问
pub use self::user::User;
pub use self::post::Post;
// src/main.rs
use crate::models::{User, Post};

fn main() {
    let user = User { id: 1, name: "Alice".to_string() };
    let post = Post { id: 1, title: "Rust模块系统".to_string() };
    println!("用户: {:?}, 文章: {:?}", user, post);
}

实用应用

大型项目结构

// 大型Rust项目结构示例
// backend/
// ├── Cargo.toml
// ├── src/
// │   ├── main.rs
// │   ├── lib.rs
// │   ├── api/           // API层
// │   │   ├── mod.rs
// │   │   ├── routes.rs
// │   │   └── middleware.rs
// │   ├── domain/        // 领域模型
// │   │   ├── mod.rs
// │   │   ├── user.rs
// │   │   ├── post.rs
// │   │   └── comment.rs
// │   ├── infrastructure/ // 基础设施
// │   │   ├── mod.rs
// │   │   ├── database.rs
// │   │   └── cache.rs
// │   ├── application/   // 应用服务
// │   │   ├── mod.rs
// │   │   ├── user_service.rs
// │   │   ├── post_service.rs
// │   │   └── comment_service.rs
// │   └── utils/         // 工具函数
// │       ├── mod.rs
// │       └── helpers.rs
// ├── tests/             // 测试
// │   ├── integration/
// │   └── unit/
// └── migrations/        // 数据库迁移

库设计

// src/lib.rs
//! 这是一个示例库

pub mod utils;
pub mod data_structures;

// 重导出常用功能
pub use utils::helpers::{add, subtract};
pub use data_structures::linked_list::LinkedList;
// src/utils/mod.rs
pub mod helpers;
// src/utils/helpers.rs
/// 加法函数
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

/// 减法函数
pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}

// 私有辅助函数
fn validate_input(a: i32, b: i32) -> bool {
    // 验证逻辑
    true
}
// src/data_structures/mod.rs
pub mod linked_list;
// src/data_structures/linked_list.rs
/// 链表节点
pub struct Node<T> {
    value: T,
    next: Option<Box<Node<T>>>,
}

/// 链表
pub struct LinkedList<T> {
    head: Option<Box<Node<T>>>,
    length: usize,
}

impl<T> LinkedList<T> {
    /// 创建新链表
    pub fn new() -> Self {
        LinkedList { head: None, length: 0 }
    }
    
    /// 添加元素
    pub fn push(&mut self, value: T) {
        let new_node = Box::new(Node { value, next: self.head.take() });
        self.head = Some(new_node);
        self.length += 1;
    }
    
    /// 移除元素
    pub fn pop(&mut self) -> Option<T> {
        self.head.take().map(|node| {
            self.head = node.next;
            self.length -= 1;
            node.value
        })
    }
    
    /// 获取长度
    pub fn len(&self) -> usize {
        self.length
    }
    
    /// 检查是否为空
    pub fn is_empty(&self) -> bool {
        self.length == 0
    }
}

最佳实践

1. 合理组织模块结构

  • 根据功能划分模块,保持模块的职责单一
  • 使用分层结构,如API层、服务层、领域层、基础设施层
  • 保持模块的大小适中,避免过大的模块

2. 正确使用可见性控制

  • 遵循最小权限原则,只公开必要的接口
  • 使用pub关键字公开需要被外部访问的项
  • 使用pub(crate)、pub(super)等关键字控制更细粒度的可见性

3. 模块的命名和路径

  • 使用蛇形命名法(snake_case)命名模块和文件
  • 模块名应该清晰地反映其功能
  • 使用crate::前缀引用当前crate的模块
  • 使用super::前缀引用父模块

4. 模块的导入

  • 使用use关键字导入常用的类型和函数,减少重复的路径
  • 对于频繁使用的项,可以使用as关键字重命名
  • 避免过度导入,只导入必要的项

5. 文档和注释

  • 为模块添加文档注释(//!),说明模块的功能和用途
  • 为公开的函数、结构体等添加文档注释(///)
  • 使用#[doc(hidden)]属性隐藏不希望出现在文档中的项

常见问题和解决方案

1. 模块未找到错误

问题:编译时出现error[E0432]: unresolved import错误

解决方案:

  • 检查模块路径是否正确
  • 确保模块文件存在
  • 确保模块被正确声明(使用mod关键字)
  • 确保模块中的项被正确导出(使用pub关键字)

2. 可见性错误

问题:编译时出现error[E0603]: function is private错误

解决方案:

  • 检查是否需要将函数或结构体设为公开(添加pub关键字)
  • 检查是否在正确的作用域内访问私有项
  • 考虑使用pub(crate)或pub(super)等更细粒度的可见性控制

3. 循环依赖

问题:模块之间存在循环依赖

解决方案:

  • 重构代码,提取共享的功能到独立的模块
  • 使用 trait 来解耦模块之间的依赖
  • 重新组织模块结构,避免循环依赖

总结

Rust的模块系统是其核心特性之一,它提供了一种结构化的方式来组织代码,使得代码更加清晰、可维护。通过合理使用模块系统和可见性控制,我们可以构建更加模块化、可重用的代码。

在实际开发中,模块系统常用于:

  • 组织大型项目的代码结构
  • 构建可重用的库
  • 控制代码的可见性,保护内部实现
  • 提高代码的可维护性和可读性

通过掌握Rust的模块系统和可见性控制,我们可以编写更加清晰、结构化的Rust代码,提升项目的质量和可维护性。

基准电压 + 运放 + 低边MOS恒流源控制原理 因为恒流源强制 Iout不变,而 Vin​ 增加时,负载压降 Iout⋅Rload不变,多余的电压只能由MOS管的 VDS承担,因此 VDS必然增加。在饱和区,MOS 管的 ID 仅由 VGS决定,与 VDS 无关,这样,负载变化时,VDS可自由调整以维持 Iout恒定。当 Vin​ 小到无法满足 VDS>VGS−Vth时,MOS管进入线性区,Iout 会随 Vin​ 下降而减小,恒流失效。由于 Vref和 Rsense未变,Iout无需调整,运放无需动作,OUT保持不变,Iout恒定。 阅读详情

相关推荐

编译opencv4.2时出现undefined reference to `jpeg_default_qtables‘错误的解决方案

操作系统:kylinV10 opencv版本:4.2.0 在编译opencv4.2.0的版本时,出现undefined reference to `jpeg_default_qtables’的错误提示,导致openc编译中断,不能继续编译,所以这个错误必须解决。 解决方案 查看错误的名字,根据名字分析,很有可能是当前系统中没有安装jpeg第三方库,到 http://www.ijg.org/上下载最新的源码包 jpegsrc.v9e.tar.gz,按如下顺序开始编译安装: tar -xzvf jpegsr.

jndingxin的专栏 5108

Rust专项——模块系统详解:组织代码的艺术

Rust模块系统提供了强大的代码组织能力,主要包括模块基础、可见性控制和模块导入三个方面。通过mod关键字可以定义模块,默认情况下模块内项是私有的,使用pub关键字控制可见性级别,包括完全公开、crate内可见和指定路径可见。use关键字用于导入模块项,支持重命名和批量导入,配合self和super可以灵活引用当前模块和父模块的内容。该系统有效解决了代码组织、命名冲突和依赖管理问题,是构建大型Rust项目的关键机制。

红目香薰 1443

Halcon形状模板匹配实战:inspect_shape_model参数优化指南

本文深入解析Halcon形状模板匹配中inspect_shape_model参数的优化技巧,涵盖NumLevels和Contrast参数的实战应用。通过具体案例展示如何平衡匹配速度与精度,帮助开发者高效调试形状模型,提升工业视觉检测的准确性和效率。

weixin_30342209的博客 619

拆解 Rust 的代码组织哲学:从模块系统到工程级模块化设计

Rust 不仅是一门强调性能与安全的系统语言,更是一门的语言。在大型项目中,单文件代码很快变得难以维护,因此合理的就成为 Rust 工程的灵魂。Rust 的模块系统(Module System)不仅是命名空间的管理机制,更是一套贯穿从文件组织、访问控制到包(crate)依赖的完整工程哲学。本文将系统解读 Rust 的模块化设计,从语法结构、文件组织到跨 crate 复用,展示如何在实际项目中构建清晰、可扩展的代码架构。

2501_94035379的博客 1690

一次携程酒店 phantom-token 逆向实战复盘(附python纯算)

摘要 本文介绍了通过分析携程酒店列表页面的数据接口,使用Python实现抓取的方法。主要内容包括: 目标站点为携程酒店列表页,通过开发者工具发现关键接口fetchHotelList 将浏览器请求转换为Python代码,包含请求头(headers)、Cookies和POST数据 提供完整的请求示例代码,包含日期参数、城市ID等必要信息 特别声明仅供学习交流使用,禁止商业用途 展示了如何获取酒店列表数据,包括排序筛选等参数设置 该方法可用于研究酒店数据采集,但需要注意遵守网站使用条款。

自成背后的博客 3034

2024年软考信息安全工程师备考历年真题汇总

信息安全工程师分属“信息系统”专业,位处中级资格,2016年下半年,第一次开考信息安全工程师(中级)考试。目前每年考试一次。已开考六次,2016年11月12日,2017年5月20日,2018年5月26日,2019年5月25日,2020年11月7日,2021年11月6日为第六次考试。 第五次和第六次考试,采用第二版教材。 2024年软考信息安全工程师备考历年真题汇总

月梦工作室 5109

Rust模块系统完全指南:构建可维护的代码结构

Rust的模块系统通过层次化的代码组织、精细的可见性控制和清晰的路径管理,帮助开发者构建高内聚低耦合的代码库。本文将用7个示例带你全面掌握模块系统的核心用法。

美味小鱼的杂货铺 1137

天龙八部TLBB系列 - 网单用数据库修改为其他门派

专注于Android/Unity和各种游戏开发技巧,以及各种资源分享(网站、工具、素材、源码、游戏等) --- 天龙八部修改门派

空名先生 9432

Rust RFCs 中的模块系统改革:从文件组织到可见性控制

Rust 模块系统是语言的核心特性之一,它通过精心的设计来管理代码的组织结构和可见性规则。在 Rust RFCs 中,模块系统经历了多次重要改革,从文件系统层次结构到精细的可见性控制,这些变化极大地改善了开发者的使用体验。本文将深入探讨 Rust RFCs 中模块系统的关键改革,帮助您理解这些改进如何让代码组织更加清晰和可控。 作为一门现代系统编程语言,Rust 的模块系统设计旨在平衡灵活性和安

gitblog_00824的博客 576

从菜鸟到大神:VSCode助力HTML开发全攻略

本文全面介绍 VSCode 在 HTML 开发中的高效应用。先引导读者完成 VSCode 的安装与个性化设置,助其快速适应开发环境;接着推荐 Live Server、Prettier 等实用插件,实现实时预览、代码格式化等功能,提升开发效率。通过详细的开发实战步骤,从新建文件到添加样式,带领读者掌握 HTML 基础结构与常用标签使用。还分享代码片段管理、多人协作等进阶技巧,解决常见开发问题。旨在帮助开发者利用 VSCode,轻松高效完成 HTML 开发,打造优质网页。

邓邓子的博客 3369

YOLO十年演进:从CNN到Transformer再到MoE,我看懂了2026年目标检测的落地风向标

技术永远是为业务服务的,能解决真实问题的技术,才是有价值的。YOLO的十年演进,从CNN到Transformer再到MoE,从来都不是学术上的炫技,而是一步一步解决工业落地的痛点:从让实时检测成为可能,到解决复杂场景的漏检误检,再到打破精度和算力的死局,每一步都踩在了工业落地的真实需求上。很多新入行的朋友,总喜欢追新,今天换Transformer,明天堆MoE,觉得模型越新、参数越大,就越厉害。

专注于Python爬虫开发,分享爬虫技巧、项目实战与反爬经验,使用Scrapy、BeautifulSoup等工具,解决数据抓取难题。 755

【Rust编程:从小白入坑】Rust模块系统详解

Rust模块系统总结 Rust通过模块系统(Module)组织代码,提供以下核心功能: 模块定义:使用mod关键字创建嵌套模块结构,默认私有 路径访问:支持绝对路径(crate::)和相对路径(super::) 可见性控制:pub关键字管理公开/私有访问 结构体/枚举可见性:结构体字段需单独公开,枚举变体默认公开 代码引入:use关键字简化路径,支持嵌套路径和glob运算符 模块分割:可将模块拆分到不同文件,提高可维护性 通过模块系统,Rust实现了清晰的代码组织、作用域控制和封装性管理。

2501_92232234的博客 922

CVPR 2026 即插即用 | 注意力篇 | PFG:多尺度大核+像素级频率门控,特征显著增强,精准适配边缘纹理场景

本文提出了一种基于频率引导的轻量级外围门控模块PFG,用于高效时空预测学习。该模块通过多尺度大核分解卷积(1×K + K×1)捕捉外围空间依赖,同时利用固定频率滤波器提取高频线索,动态融合不同尺度的外围特征。核心创新包括:外围聚焦的多尺度空间增强、频率引导的动态融合机制、双阶段归一化协同等。实验表明,PFGNet在多个基准数据集上达到SOTA性能,同时保持较低计算复杂度。该模块可直接嵌入各类视觉模型,适用于需要强化空间-通道协同表达的轻量级任务。

主要更新底层视觉(去噪、超分等)相关的科研内容,形式为【论文精读】+【论文复现】 486

【Rust工程化实战】:如何用模块系统构建可维护的百万行代码项目

掌握Rust模块系统的设计精髓,解决大型项目代码组织难题。适用于百万行规模系统的分层架构设计,通过合理划分模块、控制可见性与路径管理提升可维护性。本文深入解析实际工程中的最佳实践,值得收藏。

AlgoFun的博客 972

华为的C语言编程规范.pdf

华为技术有限公司内部技术规范。本规范制定了编写C语言程序的基本原则、规则和建议。从代码的清晰、简洁、可测试、安全、程序效率、可移植各个方面对C语言编程作出了具体指导。

迈瑞BS系列全自动生化分析仪LIS协议接口手册(内含HL7和ASTM)

迈瑞BS系列全自动生化分析仪LIS协议接口手册,内含HL7和ASTM)

Rust-by-example-cn模块系统解析:如何组织大型Rust项目的代码结构

在Rust编程语言中,模块系统是构建大型项目的核心架构工具。Rust-by-example-cn作为Rust官方示例的中文翻译项目,完美展示了如何通过模块系统组织复杂的代码结构。本文将深入解析Rust模块系统的核心概念,帮助你掌握组织大型Rust项目的关键技巧。🚀 ## 🔍 Rust模块系统基础概念 Rust的模块系统提供了一套强大的代码组织机制,可以将代码按逻辑层次分成多个模块,并精细控

gitblog_00480的博客 868

深度学习工具包 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")

从零构建模块化Rust应用:3步实现清晰项目结构

掌握Rust模块系统设计精髓,3步构建清晰可维护的项目结构。适用于中大型Rust应用开发,通过合理组织模块层级、控制可见性与路径管理,提升代码复用与协作效率。从零开始实现模块化架构,值得收藏。

PixelIsle的博客 761

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

Rust 模块系统实战:从模块树、路径可见性到文件拆分与跨 crate 访问(Rust By Practice 深度解析)

模块(module)是 Rust 组织代码的核心机制:它把 crate 内的代码按逻辑分组,提升可读性与复用性;同时模块也是 Rust 唯一的两级可见性(`public` / `private`)控制单元,决定了一个条目能否被外部代码看见。本文基于 Rust By Practice 仓库中 `crate-module` 章节的实战练习,完整讲解如何从零搭建模块树、使用绝对/相对路径调用模块内函数、

gitblog_00847的博客 669

Rust模块系统全解析:node-to-rust项目的代码组织最佳实践

Rust模块系统是构建大型项目的核心基础,它通过清晰的代码组织方式帮助开发者管理复杂依赖关系。本文将以node-to-rust项目为实例,详细解析Rust模块系统的核心概念、最佳实践以及常见问题解决方案,帮助开发者快速掌握这一关键技能。 ## 模块系统核心概念 Rust的模块系统采用层次化结构,通过`mod`关键字定义模块,使用`pub`关键字控制可见性。在node-to-rust项目中,我们

gitblog_00626的博客 744

Rust模块系统与可见性控制

例如,一个网络库可能包含`protocol`和`transport`子模块,分别处理协议解析与数据传输。通过模块系统,开发者可以将代码逻辑划分为清晰的层次结构,而可见性规则则确保代码的访问权限得到合理控制。为了减少冗长的模块路径,Rust提供了`use`关键字,允许将模块或项引入当前作用域。例如,`use std::collections::HashMap`后,可以直接使用`HashMap`而不需要完整路径。例如,`pub fn`允许函数在模块外调用,而`pub(crate)`则限制为当前包内可见。

sxwuht_320的博客 186

锈(Rust)的“清晰边界”:从模块系统看其封装与安全哲学

摘要:Rust的模块系统通过显式声明和默认私有机制实现严格的代码边界控制。核心组织单元是Crate(包),内部通过逻辑模块树管理而非简单映射文件系统。mod定义模块结构,use创建引用快捷方式。pub关键字和pub(crate)等可见性修饰符构建精细访问控制,支持内部API封装。专业实践包括API门面模式(pub use)和Prelude模式,优化公共接口设计。这种编译期强制的架构思考使Rust特别适合构建可靠的大型系统,其模块系统与借用检查器共同体现了"编译时捕获错误"的核心哲学。

2401_83865426的博客 808

Rust 代码组织与模块化:构建可维护的大型项目

本文深入探讨了Rust代码组织的最佳实践。Rust的模块系统提供了强大的代码组织能力,包括树形层次结构、文件系统映射和路径引用机制。通过pub可见性控制实现细粒度封装,包括crate级、模块级和字段级的访问控制。Workspace机制支持多crate项目分解,实现编译并行化和依赖隔离。领域驱动设计指导模块划分,通过垂直切割业务领域、共享内核和反腐败层实现高内聚低耦合。实践部分展示了典型workspace配置、核心业务逻辑封装、统一错误处理和领域模块实现。这些技术共同构成了构建可维护大型Rust项目的核心方法

超哥的博客 938

Rust 代码组织与模块化:构建清晰的工程边界

Rust 的模块化系统远不止是文件组织。它是一个强大的、在编译期强制执行的架构工具。通过强制的模块树、默认私有性以及精细化的可见性控制(特别是pub(crate)),Rust 鼓励开发者构建高内聚、低耦合的代码。掌握它,意味着你不仅在组织文件,更是在设计清晰、健壮且易于长期维护的软件工程边界。

weixin_44660085的博客 517

Zig 模块系统详解:从文件到命名空间,与 Rust 的模块哲学对比

Rust 的模块系统像一座精心设计的城堡:有城墙(pub)、城门(use)、内部庭院(mod),安全但需学习规则。Zig 的模块系统像一片开阔的田野:每个文件是一座独立小屋,路径清晰,往来直接,自由但需自律。理解 Zig 的“文件即模块”模型,不仅能写出更地道的代码,更能体会到其“显式、简单、无隐藏”的设计之美。📌记住:在 Zig 中,组织代码的最佳方式不是嵌套,而是拆分——把大文件拆成小文件,用@import连接,用pub暴露接口。这就是 Zig 的模块之道。

muyouking 999

【Rust模块系统深度解析】:掌握大型项目架构设计的核心秘诀

掌握Rust模块系统核心原理,解决大型项目代码组织难题。详解模块定义、路径管理与访问控制,适用于复杂项目架构设计。通过层级化模块结构提升代码复用与可维护性,理清私有与公有边界,实现高效协作开发。值得收藏的Rust模块系统深度指南,点击了解实战技巧。

PoliVein的博客 1124

【Rust语法】模块系统与可见性

不是"导入"。

ruiqideng的博客 191

Rust模块系统详解:从sunface/rust-by-practice项目学习代码组织

Rust模块系统详解:从sunface/rust-by-practice项目学习代码组织 【免费下载链接】rust-by-practice Learning Rust By Practice, narrowing the gap between beginner and skilled-dev through chal...

gitblog_00950的博客 481
上一篇: Rust 文件I/O操作实战:高效处理文件系统
下一篇: Python 网络编程实战:构建可靠的网络应用
第一程序员
博客等级 码龄1年 1万+粉丝 1827原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值