Rust 学习笔记:管理项目中的代码

基于Rust的Polars学习笔记 摘要:基于Rust的Polars的学习笔记 ,高性能数据分析,实时数据管道,嵌入式数据分析,WebAssembly应用 数据库加速层,地理空间数据处理,金融量化研究,生物信息学技术 阅读详情

Rust 学习笔记:管理项目中的代码

在编写大型程序时,组织代码将变得越来越重要。对相关功能进行分组,并将具有不同特性的代码分开。

到目前为止,我们编写的程序都在一个模块中的一个文件中。随着项目的增长,需要通过将代码拆分为多个模块和多个文件来组织代码。一个包可以包含多个二进制 crate,也可以包含一个库 crate。随着包的增长,可以将各个部分提取到单独的箱中,从而成为外部依赖项。

封装:一旦实现了一个操作,其他代码就可以通过其公共接口调用代码,而不必知道实现是如何工作的。编写代码的方式定义了哪些部分对其他代码是公开的,哪些部分是私有的。

一个相关的概念是作用域:编写代码的嵌套上下文具有一组定义为“在作用域中”的名称。在读取、编写和编译代码时,程序员和编译器需要知道特定位置的特定名称是否指的是变量、函数、结构体、枚举、模块、常量或其他项,以及该项的含义。可以创建作用域并更改作用域内或作用域外的名称。同一个作用域中不能有两个名称相同的项,但可以使用工具来解决名称冲突。

Rust 有许多管理代码组织的特性,包括哪些细节是公开的,哪些细节是私有的,以及程序中每个作用域中的名称。这些功能有时统称为模块系统,包括:

  • Packages:一个 Cargo 特性,构建、测试和共享
  • Crates:生成库或可执行文件的模块树
  • Modules(模块):控制 Paths 的组织、范围和私密性
  • Paths: 一种命名项目的方式,如结构体、函数或模块

Package 和 Crate

crate 是 Rust 编译器一次考虑的最小代码量。即使你运行 rustc 而不是 cargo,并且传递一个源代码文件,编译器也会认为该文件是一个 crate。crate 可以包含模块,这些模块可以在使用 crate 编译的其他文件中定义。

crate 有两种形式:二进制 crate 或库 crate。

二进制 crate 是可以编译为可运行的可执行文件的程序,例如命令行程序或服务器。每个程序都必须有一个名为 main 的函数,用于定义可执行程序运行时发生的情况。到目前为止我们创建的所有箱子都是二进制的。

库 crate 没有 main 函数,也不能编译成可执行文件。相反,它们定义了旨在与多个项目共享的功能。例如,我们之前使用的 rand crate 提供了生成随机数的功能。

crate 根文件是 Rust 编译器启动的源文件,它构成了 crate 的根模块。

package 是提供一组功能的一个或多个 crate 的集合。一个 package 包含一个 Cargo.toml,这个文件描述如何构建这些 crate。Cargo 实际上是一个 package,其中包含用于构建代码的命令行工具的二进制 crate。Cargo package 还包含一个二进制 crate 所依赖的库 crate。其他项目可以依赖 Cargo 库 crate 来使用 Cargo 命令行工具使用的相同逻辑。一个 package 可以包含任意多个二进制 crate,但最多只能包含一个库 crate。一个 package 必须包含至少一个 crate,无论是库 crate 还是二进制 crate。

让我们来看看创建 package 时会发生什么。首先我们输入命令 cargo new my-project:

$ cargo new my-project
     Created binary (application) `my-project` package
$ ls my-project
Cargo.toml
src
$ ls my-project/src
main.rs

在项目目录中,有一个 Cargo.toml 文件,这就是一个 package。

还有一个包含 main.rs 的 src 目录。Cargo 遵循 src/main.rs 是与包同名的二进制 crate 的根目录。同样,Cargo 知道如果包目录包含 src/lib.rs 中,package 包含与包同名的库 crate,并且 src/lib.rs 是它的根。Cargo 将 crate 根文件传递给 rustc 以构建库或二进制文件。

这里,我们有一个只包含 src/main.rs 的 package,这意味着它只包含一个名为 my-project 的二进制 crate。

如果一个 package 包含 src/main.rs 和 src/lib.rs。在这里,它有两个 crate:一个二进制文件和一个库,它们的名字都和包的名字一样。通过在 src/bin 目录下放置文件,一个包可以有多个二进制 crate:每个文件将是一个单独的二进制 crate。

定义模块来控制作用域和私有性

在本节中,我们将讨论模块和模块系统的其他部分,即路径(Path),它允许命名项;use 关键字将路径引入作用域;pub 关键字使项目公开。我们还将讨论 as 关键字、外部 package 和 glob 操作符。

模块的工作方式

在详细介绍模块和路径之前,我们先简要介绍模块、路径、use 关键字和 pub 关键字在编译器中的工作方式,以及大多数开发人员如何组织他们的代码。

当编译一个 crate 时,编译器首先查找 crate 根文件(通常是 src/lib.rs 作为库 crate 或 src/main.rs 作为二进制 crate),用于编译代码。

在 crate 根文件中可以声明新的模块。假设你用 mod garden; 声明了一个“花园”模块。编译器会在这些地方查找模块的代码:

  • 内联的,在取代 mod garden 后面分号的花括号内
  • src/garden.rs 文件
  • src/garden/mod.rs 文件

在 crate 根目录之外的任何文件中,都可以声明子模块。例如,你可以在 src/garden.rs 内声明 mod vegetables;。编译器将在以下地方以父模块命名的目录中查找子模块的代码:

  • 内联的,直接跟在 mod vegetables 后面,用花括号代替分号
  • src/garden/vegetables.rs 文件
  • src/garden/vegetables/mod.rs 文件

一旦模块成为 crate 的一部分,只要隐私规则允许,就可以使用代码路径从同一 crate 中的任何其他地方引用该模块中的代码。例如,garden vegetables 模块中的 Asparagus 类型可以通过 crate::garden::vegetables::Asparagus 找到。

默认情况下,模块内的代码对其父模块是私有的。要使一个模块为公共,请使用 pub mod 声明它。要使公共模块中的项也为公共,请在声明它们之前使用 pub。

在作用域中,use 关键字创建项的快捷方式,以减少长路径的重复。在任何可以引用 crate::garden::vegetables::Asparagus 的作用域中,你可以通过 use crate::garden::vegetables::Asparagus; 创建一个快捷方式。从那时起,你只需要编写 Asparagus 就可以在作用域中使用该类型。

在这里,我们创建了一个名为 backyard 的二进制箱子来说明这些规则。crate 的目录也被命名为backyard,包含这些文件和目录:

backyard
├── Cargo.lock
├── Cargo.toml
└── src
    ├── garden
    │   └── vegetables.rs
    ├── garden.rs
    └── main.rs

在本例中,crate 的根文件是 src/main.rs,它包含:

use crate::garden::vegetables::Asparagus;

pub mod garden;

fn main() {
    let plant = Asparagus {};
    println!("I'm growing {plant:?}!");
}

pub mod garden; 告诉编译器去 src/garden.rs 找其包含的代码,其代码为:

// src/garden.rs
pub mod vegetables;

pub mod vegetables; 再告诉编译器去 src/garden/vegetables.rs 找其包含的代码,其代码为:

#[derive(Debug)]
pub struct Asparagus {}

对模块中的相关代码进行分组

模块让我们在一个 crate 中组织代码,以提高可读性和重用性。模块还允许我们控制项的私密性,因为模块中的代码在默认情况下是私有的。私有项是外部无法使用的内部实现细节。我们可以选择将模块和其中的项设为公共,这样就可以让外部代码使用和依赖它们。

例如,让我们编写一个提供餐厅功能的库 crate。运行 cargo new restaurant --lib 创建一个名为 restaurant 的新库,然后在 src/lib.rs 中定义一些模块和函数签名:

mod front_of_house {
    mod hosting {
        fn add_to_waitlist() {}

        fn seat_at_table() {}
    }

    mod serving {
        fn take_order() {}

        fn serve_order() {}

        fn take_payment() {}
    }
}

我们使用 mod 关键字后跟模块名(在本例中为 front_of_house)来定义模块。在模块内部(花括号内),我们可以放置其他模块,就像本例中托管和服务模块一样。模块还可以保存其他项的定义,比如结构体、枚举、常量、trait 和函数。

通过使用模块,我们可以将相关的定义分组在一起,并说明它们相关的原因。使用此代码的程序员可以根据组导航代码,而不必通读所有定义,从而更容易找到与组相关的定义。向这段代码添加新功能的程序员应该知道将代码放在哪里,以保持程序的组织性。

前面我们提到 src/main.rs 和 src/lib.rs 被称为 crate 根文件。命名的原因是这两个文件的内容在 crate 的模块结构(称为模块树)的根位置形成了一个名为 crate 的模块。

restaurant 库的模块树如下所示:

crate
 └── front_of_house
     ├── hosting
     │   ├── add_to_waitlist
     │   └── seat_at_table
     └── serving
         ├── take_order
         ├── serve_order
         └── take_payment

这个树显示了一些模块如何嵌套在其他模块中,整个模块树都植根于名为 crate 的隐式模块。

如果模块 A 包含在模块 B 中,我们说模块 A 是模块 B 的子模块,模块 B 是模块 A 的父模块。同一层级的模块叫做兄弟模块。

模块树如同计算机上文件系统的目录树。就像目录中的文件一样,我们需要一种找到模块的方法。

包含二进制文件和库的 package 的最佳实践

我们提到过一个 package 可以同时包含 src/main.rs(二进制 crate 根文件)以及 src/lib.rs 两个 crate。

默认情况下,两个 crate 都有包名。通常,具有这种既包含库 crate 又包含二进制 crate 的 package 在二进制 crate 中会有足够的代码来启动调用库 crate 中的代码的可执行文件。这使得其他项目可以从包提供的大部分功能中受益,因为库 crate 的代码可以共享。

模块树应该在 src/lib.rs 中定义。然后,任何公共项目都可以通过以包名开始的路径在二进制 crate 中使用。二进制 crate 成为库 crate 的用户,就像一个完全外部的 crate 使用库 crate 一样:它只能使用公共 API。

这有助于你设计一个好的 API。因为你不仅是作者,还是客户!

在模块树中引用项目的路径

要调用一个函数,我们需要知道它的路径。

路径有两种形式:

  • 绝对路径是从 crate 根目录开始的完整路径。对于来自外部 crate 的代码,绝对路径以该 crate 的名称开头;而对于来自当前 crate 的代码,它以 crate:: 开头。

  • 相对路径从当前模块开始,使用当前模块中的 self、super 或标识符。

绝对路径和相对路径都使用 :: 标识符做分隔。

假设我们想调用 add_to_waitlist 函数,要先找到它的路径,于是有两种方式调用:

mod front_of_house {
    mod hosting {
        fn add_to_waitlist() {}
    }
}

pub fn eat_at_restaurant() {
    // Absolute path
    crate::front_of_house::hosting::add_to_waitlist();

    // Relative path
    front_of_house::hosting::add_to_waitlist();
}

eat_at_restaurant 函数是库 crate 的公共 API 的一部分,所以我们用 pub 关键字标记它。

虽然上面的代码中绝对路径和相对路径的写法没有问题,但不能通过编译。报错:error[E0603]: module `hosting` is private。

原因是模块 host 是私有的,Rust 不允许访问模块的私有部分。在 Rust 中,默认情况下,所有项(函数、方法、结构、枚举、模块和常量)对父模块都是私有的。父模块中的项不能使用子模块中的私有项,但子模块中的项可以使用其祖先模块中的项。这是因为子模块封装并隐藏了它们的实现细节,但是子模块可以看到它们被定义的上下文。

使用 pub 关键字公开路径

Rust 提供 pub 关键字,可以将一个项设为 public,将子模块代码的内部部分公开给外部祖先模块。

将模块设为公共并不会将其内容设为公共。模块上的 pub 关键字只允许其祖先模块中的代码引用它,而不能访问其内部代码。我们需要更进一步,选择将模块中的一个或多个项也设置为公共项。

mod front_of_house {
    pub(crate) mod hosting {
        pub(crate) fn add_to_waitlist() {}
    }
}

可以简化:

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
    }
}

以 super 开头的相对路径

通过在路径的开头使用 super,我们可以构建从父模块开始的相对路径,而不是从当前模块或 crate 根模块开始。

fn deliver_order() {}

mod back_of_house {
    fn fix_incorrect_order() {
        cook_order();
        super::deliver_order();
    }

    fn cook_order() {}
}

fix_incorrect_order 函数位于 back_of_house 模块中,因此我们可以使用 super 转到 back_of_house 的父模块,在本例中是 crate,即根模块。从那里,我们寻找 deliver_order 并找到它。成功!

使用 super,如果将来这些代码被移动到不同的模块,我们将有更少的地方更新代码。

使结构和枚举成为 public

结构体和枚举默认是 private 的,我们也可以使用 pub 将结构体和枚举指定为 public。

如果在结构体定义之前使用 pub,则将结构体设为 public,但结构体的字段仍然是 private。我们可以根据具体情况将每个字段公开或不公开。

我们定义一个公共的 back_of_house::Breakfast 结构体,它有一个公共的 toast 字段,但有一个私有的 seasonal_fruit 字段:

mod back_of_house {
    pub struct Breakfast {
        pub toast: String,
        seasonal_fruit: String,
    }

    impl Breakfast {
        pub fn summer(toast: &str) -> Breakfast {
            Breakfast {
                toast: String::from(toast),
                seasonal_fruit: String::from("peaches"),
            }
        }
    }
}

pub fn eat_at_restaurant() {
    // Order a breakfast in the summer with Rye toast
    let mut meal = back_of_house::Breakfast::summer("Rye");
    // Change our mind about what bread we'd like
    meal.toast = String::from("Wheat");
    println!("I'd like {} toast please", meal.toast);

    // The next line won't compile if we uncomment it; we're not allowed
    // to see or modify the seasonal fruit that comes with the meal
    // meal.seasonal_fruit = String::from("blueberries");
}

注意,因为 back_of_house::Breakfast 有一个私有字段,所以该结构体需要提供一个公共关联函数来构造一个 Breakfast 的实例(我们在这里将其命名为 summer)。如果 Breakfast 没有这样的函数,我们就不能在 eat_at_restaurant 中创建 Breakfast 的实例,因为我们不能在 eat_at_restaurant 中设置私有的 seasonal_fruit 字段的值。

相反,如果将枚举设为 public,则它的所有变体都是 public。我们只需要在 enum 关键字之前添加 pub:

mod back_of_house {
    pub enum Appetizer {
        Soup,
        Salad,
    }
}

pub fn eat_at_restaurant() {
    let order1 = back_of_house::Appetizer::Soup;
    let order2 = back_of_house::Appetizer::Salad;
}

在每种情况下都必须用 pub 来注释所有枚举变量是很烦人的,所以枚举变量的默认值是 public。

还有一种涉及pub的情况我们还没有讨论,那是我们模块系统的最后一个特性:use关键字。我们将首先介绍use本身,然后我们将展示如何将pub和use结合起来。

使用 use 关键字将路径引入作用域

必须写出调用函数的路径会让人觉得不方便且重复。幸运的是,有一种方法可以简化这个过程:我们可以用 use 关键字创建一个路径的快捷方式,然后在作用域的其他地方使用更短的名称。

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
    }
}

use crate::front_of_house::hosting;

pub fn eat_at_restaurant() {
    hosting::add_to_waitlist();
}

通过在 crate 根目录中添加 use crate::front_of_house::hosting, hosting 现在是该作用域内的有效名称,就像在 crate 根目录中定义了 hosting 模块一样。

注意,use 仅为发生使用的特定作用域创建快捷方式。

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
    }
}

use crate::front_of_house::hosting;

mod customer {
    pub fn eat_at_restaurant() {
        hosting::add_to_waitlist();
    }
}

将 eat_at_restaurant 函数移动到名为 customer 的新子模块中,该子模块的作用域与 use 语句不同,因此函数体无法编译。

use 的常见使用方法

一般使用 use 将函数的父模块带入作用域即可。这意味着我们必须在调用函数时指定父模块。

在调用函数时指定父模块可以清楚地表明该函数不是本地定义的,同时仍然可以最大限度地减少完整路径的重复。

示例:

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
    }
}

use crate::front_of_house::hosting;

pub fn eat_at_restaurant() {
    hosting::add_to_waitlist();
}

另一方面,在使用 struct、enum 和其他项时,习惯上指定完整路径。下面演示了将标准库的 HashMap 结构体引入二进制 crate 作用域的惯用方法。

use std::collections::HashMap;

fn main() {
    let mut map = HashMap::new();
    map.insert(1, 2);
}

这种习惯用法背后没有什么强有力的理由,它只是一种已经出现的约定,人们已经习惯了以这种方式阅读和编写 Rust 代码。

这种习惯用法的例外情况是,如果我们使用 use 语句将两个同名的项带入作用域,因为 Rust 不允许这样做。下面演示了如何将两个名称相同但父模块不同的 Result 类型引入作用域,以及如何引用它们。

use std::fmt;
use std::io;

fn function1() -> fmt::Result {
    // --snip--
}

fn function2() -> io::Result<()> {
    // --snip--
}

使用父模块可以区分两种 Result 类型。如果我们指定 use std::fmt::Result 和 use std::io::Result,我们将在同一作用域中拥有两个 Result 类型,Rust 在使用 Result 时将不知道我们指的是哪一个。

使用 as 关键字提供新名称

对于将两个具有相同名称的类型带入相同作用域的问题,还有另一种解决方案:在路径之后,我们可以为类型指定 as 和一个新的本地名称或别名。

use std::fmt::Result;
use std::io::Result as IoResult;

fn function1() -> Result {
    // --snip--
}

fn function2() -> IoResult<()> {
    // --snip--
}

在第二个 use 语句中,我们为 std::io::Result 类型选择了新名称 IoResult,它不会与 std::io::Result 冲突。

使用 pub use 重新导出名称

当使用 use 关键字将名称引入作用域时,在新作用域中可用的名称是 private。为了使调用我们代码的代码能够引用该名称,就好像它是在该代码的作用域中定义的一样,我们可以组合 pub 和 use,这种技术被称为再导出。

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
    }
}

pub use crate::front_of_house::hosting;

pub fn eat_at_restaurant() {
    hosting::add_to_waitlist();
}

在此更改之前,外部代码必须通过使用路径 restaurant::front_of_house::hosting::add_to_waitlist() 来调用 add_to_waitlist 函数,使用 pub use 之后,可以用 restaurant::hosting::add_to_waitlist() 代替。

使用外部 package

在之前的猜谜游戏中,我们在 Cargo.toml 的依赖部分添加了这一行:

rand = "0.8.5"

然后,为了将 rand 定义引入包的作用域中,我们添加了以 crate 名称 rand 开头的 use 行,并列出了我们想要引入作用域中的项。

use rand::Rng;

fn main() {
    let secret_number = rand::thread_rng().gen_range(1..=100);
}

注意,标准 std 库也是一个外部的 crate。因为标准库是随 Rust 语言一起提供的,所以我们不需要在 Cargo.toml 中显式引入。但是我们确实需要用 use 将其中的项引入作用域。例如,使用 HashMap,我们将使用这一行:

use std::collections::HashMap;

这是一个以 std 开头的绝对路径,std 是标准库的名称。

使用嵌套路径简化代码

如果我们在同一个 crate 或同一个模块中定义了多个项目,那么将每个项目单独列在一行中可能会占用文件中的大量垂直空间。

// --snip--
use std::cmp::Ordering;
use std::io;
// --snip--

我们可以使用嵌套路径将相同的项放在一行中。通过指定路径的公共部分,后面跟着 ::,然后用 {} 括起路径中不同部分的列表来实现这一点:

// --snip--
use std::{cmp::Ordering, io};
// --snip--

我们可以在路径的任何级别使用嵌套路径,这在组合两个共享子路径的 use 语句时非常有用。例如:

use std::io;
use std::io::Write;

这两个路径的共同部分是 std::io,为了将这两个路径合并为一个 use 语句,我们可以在嵌套路径中使用 self:

use std::io::{self, Write};

Glob 操作符

如果要将路径中定义的所有公共项都纳入作用域,可以指定该路径,后跟 * 操作符:

use std::collections::*;

这个 use 语句将 std::collections 中定义的所有公共项带入当前作用域。

在测试时,经常使用 * 操作符将所有要测试的东西都放入 tests 模块中。

将模块分离到不同的文件中

当模块变大时,我们将把模块提取到文件中,而不是在 crate 根文件中定义所有模块。

首先,我们将 front_of_house 模块提取到它自己的文件中。删除 front_of_house 模块花括号内的代码,只留下 mod front_of_house; 声明。

src/lib.rs:

mod front_of_house;

pub use crate::front_of_house::hosting;

pub fn eat_at_restaurant() {
    hosting::add_to_waitlist();
}

类似地,我们将 hosting 模块提取到它自己的文件中。

src/front_of_house.rs:

pub mod hosting;

src/front_of_house/hosting.rs:

pub fn add_to_waitlist() {}

这个过程有点不同,因为 hosting 是 front_of_house 的子模块,而不是根模块。我们将把用于托管的文件放在一个新目录中,该目录将以模块树中它的祖先命名,在本例中为 src/front_of_house。

mod 关键字声明了模块,Rust 会在与模块同名的文件中查找进入该模块的代码。

备用文件路径

到目前为止,我们已经介绍了 Rust 编译器使用的最惯用的文件路径,但是 Rust 还支持一种更老的文件路径。对于在 crate 根目录中声明的名为 front_of_house 的模块,编译器将在以下目录中查找该模块的代码:

  • src/front_of_house.rs(声明)
  • src/front_of_house/mod.rs(实现)

对于一个名为 hosting 的模块,它是 front_of_house 的子模块,编译器将在下面查找该模块的代码:

  • src/front_of_house/hosting.rs(声明)
  • src/front_of_house/hosting/mod. rs(实现)

Rust 允许在同一项目中的不同模块中混合使用这两种风格,但如果对同一个模块同时使用这两种风格,就会得到编译器错误。

使用名为 mod.rs 文件的风格的主要缺点是,大型项目最终可能会有许多 mod.rs,会让人搞混。

总结

Rust 允许将一个 package 拆分为多个 crate,并将一个 crate 拆分为多个模块,这样就可以从一个模块中引用另一个模块中定义的项。

引入模块可以通过指定绝对或相对路径来实现。也可以使用 use 语句将这些路径引入作用域中,这样就可以使用较短的路径来多次使用该作用域中的项。

模块代码在默认情况下是私有的,但是可以通过添加 pub 关键字使定义成为公共的。

第十二章 rust中的项目管理 前面我们已经使用了很多别人写的包,而本文就将详细介绍我们如何去写一个属于自己的包。包的作用相信大家已经有所领悟:可以共享常用代码,避免大家造轮子。在rust中,包的别名是crate,而crate则是rust编译的最小代码单位,比如我们前面写的main.rs中的代码,最终会被编译为一个二进制可执行文件。main.rs文件中的代码此时就属于我们自定义项目的一个源代码文件。这么说起来,其实它这里这个包的概念与vs中解决方案的概念很类似,而crate就像是vs中的各个项目。 阅读详情

相关推荐

Rust项目构建与管理:深入理解Cargo

本文还有配套的精品资源,点击获取 简介:Cargo是Rust编程语言的核心构建系统,负责依赖管理、编译、测试和打包等。本文详细介绍了Cargo的工作原理、子命令、插件以及如何在持续集成和部署(CI/CD)中应用。了解Cargo对于Rust开发者而言是不可或缺的,它使得构建和管理Rust项目变得更加高效和标准化。 1. Cargo作为Rust的标准构建系统 1...

weixin_42497762的博客 2828

Rust 之三 项目管理(Package、Crate、Workspace 等)

Rust 编程语言作为后起之秀,针对性的解决完善了以前编程语言的一些问题,例如,项目管理、文档编写、代码规范等等,同时又充分吸收了现代编程语言的一些特性,例如,Rust 有前端编程语言标配的包管理器,类似于前端脚手架的项目管理等。

技术干货 2654

基于斜坡补偿的Buck电路峰值电流+电压电流双闭环控制【附说明文档】(Simulink仿真实现)优快云首页发布文章优快云同步助手LLC谐振变换器开环+闭环软启动仿真设计(Simulink

内容概要:本文围绕三电平VIENNA整流器的双闭环控制与中点电位平衡问题展开仿真研究,提出了一种基于上下电容电压差值补偿的中点电位平衡策略。该策略在传统电压电流双闭环PI控制的基础上,引入电容电压差值作为反馈信号,通过SVPWM调制中冗余小矢量的时间分配实现中点电荷的定向调节,从而在不改变主控制结构的前提下有效抑制中点电位偏差。仿真结果表明,该方法不仅确保直流母线电压稳定跟踪800V给定值,还能显著提升上下电容电压的均衡度,同时保持输入电流低谐波水平,验证了控制策略的可行性和有效性。; 适合人群:电力电子、电气自动化及相关专业的研究生、科研人员及工程技术人员,具备一定的MATLAB/Simulink仿真基础和电力电子拓扑知识背景者更佳。; 使用场景及目标:①掌握三电平VIENNA整流器的工作原理与中点电位波动的成因;②理解电压电流双闭环PI控制的设计要点与参数整定原则;③学习基于差值补偿的中点电位平衡控制策略及其与SVPWM的协同机制;④应用于充电桩、航空电源、通信电源等中大功率单向整流场合的控制系统设计与优化。; 阅读建议:建议结合文中提供的仿真模型与参数设置进行动手实践,重点关注中点电位平衡投入前后电容电压波形的变化,对比分析不同工况下的系统动态响应,深入理解控制策略的作用机理。同时可进一步探索在电网不平衡、轻载等复杂工况下的控制性能,以拓展应用场景。

【Rust中的项目管理】

在开发者进行项目立项并逐步开发时,尤为重要的是项目结构和各个模块的管理,在C++中,通常我们结合文件夹以及namespace和头文件的共同作用下将项目结构变得合理,Rust为开发者提供了一整套管理体系如Package,Crates,Module &use ,Path,通过这些特性来共同管理Rust项目,开合自如。

m0_37719524的博客 2607

惯性导航技术, IMU, AHRS

惯性导航技术, IMU, AHRS

小电车没有名字 2万+

TM1621/HT1621 段码LCD驱动器

TM1621 LCD 驱动器

qq_45325304的博客 1万+

Rust学习笔记

​这是我观看杨旭老师的Rust教程的笔记,笔记中省略了一些细节部分,如有不理解的请大家观看杨旭老师的视频。

qq_59294755的博客 2190

Visual Studio Git 使用指南

Visual Studio 2022深度集成了Git功能,提供了直观的图形界面管理源代码。本文详细介绍了VS中Git的使用方法:从环境准备、克隆/创建仓库开始,重点讲解了"Git更改"窗口的日常操作,包括查看修改、暂存文件、提交推送等。同时涵盖了分支管理、查看历史、解决冲突等核心功能,以及储藏、重置等高级操作。文章还提供了实用技巧,如提交规范、频繁提交等最佳实践。VS的Git集成覆盖了日常开发需求,图形界面与命令行可互补使用,适合各层次开发者高效管理代码版本。

guigenyi的专栏 1577

Rust 实战项目:TODO 管理器

本文介绍了一个基于Rust开发的轻量级命令行TODO管理工具。该工具支持任务的增删改查、状态标记、优先级设置等功能,并采用JSON格式进行数据持久化存储。项目采用Rust标准库实现,具有跨平台兼容性强、操作高效等特点。文章详细说明了项目结构、核心代码实现,包括任务状态枚举、优先级设置、任务结构体定义等关键模块,并提供了完整的命令操作指南和使用方法。

是微风,是晚霞,是无可替代 5870

开启虚拟人物互动新时代:探索相芯Avatar SDK驱动功能(Android)

相芯SDK提供了男孩和女孩Avatar驱动模型,这些模型具备半身驱动和全身驱动的功能,使得虚拟角色能够根据用户的面部表情和动作实时模仿和响应。半身驱动功能: 相芯SDK的男孩和女孩Avatar驱动模型具备上身驱动功能,即能够通过用户的面部表情和动作来驱动虚拟角色的上半身行为。这意味着用户的面部表情、头部转动和上半身姿态等动作可以直接映射到虚拟角色上,使得虚拟角色能够栩栩如生地模仿用户的动作。例如,用户微笑时,虚拟角色会展现出笑容;用户转动头部时,虚拟角色也会相应地转动头部。

Faceunity2023的博客 633

ANSYS Workbench瞬态结构分析(1)时域分析

本文围绕瞬态结构分析展开。首先阐释其概念与理论基础,涵盖控制方程及数值求解方法。接着详述在 ANSYS Workbench 中进行瞬态分析的操作流程,以音叉为例,介绍从创建分析系统、材料定义、几何处理与网格划分,到边界条件与载荷设置、求解器设置及结果后处理的各步骤。之后对分析结果进行探讨,并针对计算不收敛、计算时间过长等常见问题给出调试技巧,旨在为读者提供全面的瞬态结构分析知识与实践指导。

qq_58675332的博客 6535

探索Rust代码质量管理新境界:SonarQube社区版Rust插件

探索Rust代码质量管理新境界:SonarQube社区版Rust插件 项目介绍 在现代软件开发中,代码质量管理是确保项目成功的重要环节。SonarQube作为一款开源的代码质量管理平台,已经成为了众多开发团队的首选工具。然而,对于Rust语言的支持,SonarQube官方并未提供原生插件。为了填补这一空白,社区开发者Eric推出了SonarQube社区版Rust插件,使得Rust开发者也能享受到S...

gitblog_00761的博客 1244

Mac 下 OpenClaw 安装全记录:从零到一的保姆级图文教程

本文主要介绍了Mac 下 OpenClaw 安装全记录:从零到一的保姆级图文教程,希望能对学习使用OpenClaw 的同学们有所帮助。 文章目录 1. 背景 2. 安装教程 2.1 安装OpenClaw 2.2 配置模型 2.3 对话 3. 后续使用步骤 4. 关闭程序

weixin_43178406的博客 11万+

Gopher的Rust第一课:Rust代码组织

在上一章的讲解中,我们编写了第一个Rust示例程序"hello, world",并给出了rustc版和cargo版本。在真实开发中,我们都会使用cargo来创建和管理Rust包。不过,Hello, world示例非常简单,仅仅由一个Rust源码文件组成,而且所有源码文件都在同一个目录中。但真实世界中的实用Rust程序,无论是公司商业项目,还是一些知名的开源项目,甚至是一些稍复杂一些的供教学使用的示...

TonyBai 1286

将Dify平台开发的工作流集成到Open WebUI中

将Dify开发的工作流集成到Open WebUI是一个能够显著增强AI应用交互能力和业务逻辑深度的有效途径。其核心在于通过API建立两者间的通信桥梁,并确保API在格式、协议和行为上的一致性,特别是向OpenAI Chat API规范看齐。最简单直接的路径是利用Dify的“对话型”或“Agent型”应用,这类应用的API设计更倾向于满足Open WebUI这类聊天前端的期望。然而,面对复杂的现实场景,直接的完美兼容并非总是唾手可得。

形上得其象,形下合于数;阴阳自济,玄理自明。 2032

贝叶斯统计 [韦来生编]

贝叶斯(Bayes)统计是近几十年来迅速发展起来的数理统计的一个重要分支。贝叶斯方法与经典统计方法的主要不同之处是进行统计推断时除了利用样本信息外,还要利用参数的先验信息,因此可以提高统计推断或统计决策的效果。它在经济、金融、生物、医学、自然科学和社会科学等许多领域具有广泛的应用。贝叶斯方法的研究已渗透到了统计学的几乎所有领域。作者在给中国科学技术大学概率论与数理统计专业本科生开设的“数理统计”课程中有一章专门讲授“贝叶斯方法和统计决策理论”,近十年来也给中国科学技术大学概率统计专业研究生开设过几次“贝叶斯分析”课。本书是在对过去讲稿的内容作了适当的增减和调整的基础上完成的。  本书共分六章。第1章是绪论,介绍了贝叶斯统计的若干基本概念,同时对必要的数理统计的基础知识有重点地作了回顾。第二章介绍了确定先验分布的若干可供选择的方法。第三章介绍了几类常见统计模型参数的后验分布的主要结果和计算方法。第四章和第五章分别介绍了“贝叶斯统计推断”和“贝叶斯统计决策”的内容。第六章介绍了贝叶斯统计计算的若干方法,包括蒙特卡洛方法和马尔可夫链蒙特卡洛(MCMC)方法以及相关统计软件的简介。本书的每一章附右大量的例题和习题,书末附有常用的几个表格和部分习题解答供读者查用。  大约可在54学时内讲授本书的第1章至第六章的主要内容,教师可根据学时需要选讲本书第1章至第六章的部分内容。书中标“*”号的章节可略去不讲,留给读者作为阅读材料。第六章例题中的R代码和部分例题的数据文件等可从作者个人主页下载。  作者在编写本书的过程中参考了J.O.Berger教授的《统计决策论及贝叶斯分析》和茆诗松教授编写的《贝叶斯统计》等书中的一些内容,以及《贝叶斯分析》一书中由张伟平博士编写的有关贝叶斯统计计算的一些内容。在此表示衷心感谢。  本书编写准备过程中,中国科学技术大学统计与金融系的几个研究生帮助完成了本书部分中文的录入和排版,作者对他们的辛勤工作表示真诚的感谢。高等教育出版社为本书的出版给予了大力支持。在此一并致谢。

Rust Workspace 多项目管理:从代码组织到系统架构的深度指南

Rust workspace 是 Cargo 提供的多项目管理机制,它允许在单一版本控制仓库中管理多个相互关联的 crates。表面上,workspace 只是简化了依赖版本管理,但其设计哲学远深于此。深入理解 workspace 的组织方式,对于构建大型系统、优化编译性能、实现代码复用的关键至关重要。💪。

2501_94041658的博客 1409

NTscan扫描工具

ntscan是一个扫描器,可以扫描没有密码和弱密码的共享,先到配置文件中填写猜测的用户名和密码,扫描过程中右侧出现的是扫描日志。

Rust学习笔记(上)

笔记的内容主要参考与《Rust 程序设计语言》,一些也参考了《通过例子学 Rust》和《Rust语言圣经》。Rust学习笔记分为上中下,其它两个地址在。

Fishermen_sail的博客 1385

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

霍尼韦尔SoftMaster使用说明

霍尼韦尔SoftMaster使用说明

Rust项目配置管理新选择:Keyshade CLI的高级用法指南

Keyshade CLI是一款面向Rust开发者的实时配置管理工具,它提供了比传统.env文件更安全、更灵活的秘密和环境变量管理方案。本文将深入探讨Keyshade CLI的高级用法,帮助Rust项目开发者轻松实现配置的安全管理与高效部署。 ## 为什么选择Keyshade CLI管理Rust项目配置? 在Rust开发中,配置管理往往面临着安全性与便捷性的双重挑战。传统的.env文件方式存在着

gitblog_01178的博客 970

Rust Workspace 的多项目管理

掌握 Workspace,不只是学会了多项目管理,更是理解了 Rust 工程化的哲学——

2501_94047039的博客 1943

Rust 学习笔记:我的第一个 Rust 程序

Rust 学习笔记:我的第一个 Rust 程序

ProgramNovice的博客 753

Rust 学习笔记:安装 Rust

Rust 学习笔记:安装 Rust

ProgramNovice的博客 1202

Rust学习笔记(下)

笔记的内容主要参考与《Rust 程序设计语言》,一些也参考了《通过例子学 Rust》和《Rust语言圣经》。Rust学习笔记分为上中下,其它两个地址在Rust学习笔记(上)和Rust学习笔记(中)。

Fishermen_sail的博客 1417

rust-plus-golang项目终极指南:如何通过FFI实现Go调用Rust代码

rust-plus-golang项目是一个实用的开源解决方案,它展示了如何通过FFI(Foreign Function Interface)技术实现Go语言调用Rust代码。本指南将为你详细介绍这一过程,帮助你快速掌握在Go项目中集成Rust代码的方法。 ## 项目简介:Rust与Go的完美结合 Rust以其内存安全和高性能著称,而Go则以简洁的语法和出色的并发处理能力受到开发者青睐。rust

gitblog_00262的博客 1071

Rust 组织管理

Rust通过模块系统实现代码组织管理,主要包含包(Package)、箱(Crate)、模块(Module)和工作空间(Workspace)四个层级。包是最小项目单位,包含Cargo.toml文件;箱是编译基本单元,分为二进制箱和库箱;模块通过mod关键字定义,支持分层组织和可见性控制;工作空间则用于管理多个相关包。典型项目结构包括主入口文件、库声明文件以及功能模块目录,通过pub关键字控制接口暴露,实现功能分离和封装性。最佳实践建议模块嵌套不超过3层,合理使用可见性修饰符,并采用清晰的目录结构。

本博客分享软硬件一体化开发实战。硬件涵盖 PCB 设计、STM32 等 MCU 底层开发;软件包含 C++、Rust,Qt/QML、PyQt、Slint、TouchGFX、LVGL 各类 GUI 框架。方便软硬件开发者查阅学习。欢迎关注! 876

推荐项目:加速你的Neovim中的Rust编程体验 —— Rustaceanvim

--- 当谈到提升代码编辑的效率与愉悦感,特别是针对像Rust这样的强大系统编程语言时,一个好的集成开发环境(IDE)或文本编辑器配置是至关重要的。今天,我们来探讨一款专为Neovim优化的开源宝藏项目——[Rustaceanvim](https://github.com/mrcjkb/rustaceanvim),它将让你在编写Rust代码时如虎添翼。 ## 项目介绍 Rustaceanvi...

gitblog_00033的博客 1040
上一篇: Rust 学习笔记:关于枚举与模式匹配的练习题
下一篇: Rust 数据结构:Vector
UestcXiye
博客等级 码龄8年 9033粉丝 1306原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

UestcXiye

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值