Rust 泛型

rust笔记12:rust的泛型 Rust 的泛型实现是其类型系统的核心特性之一,它允许编写灵活且可重用的代码,同时保持类型安全和性能。以下从 泛型数据类型、泛型类型参数、trait bound 和 生命周期泛型 四个方面详细介绍 Rust 的泛型实现,并解释编译器如何通过 静态分发 处理泛型。 阅读详情

泛型 Generics泛型详解

使用泛型参数,有一个先决条件,必需在使用前对其进行声明:

fn largest<T>(list: &[T]) -> T {

该泛型函数的作用是从列表中找出最大的值,其中列表中的元素类型为 T。首先 largest<T> 对泛型参数 T 进行了声明,然后才在函数参数中进行使用该泛型参数 list: &[T] 。

下面是一个错误的泛型函数的实现:

fn largest<T>(list: &[T]) -> T {
    let mut largest = list[0];

    for &item in list.iter() {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn main() {
    let number_list = vec![34, 50, 25, 100, 65];

    let result = largest(&number_list);
    println!("The largest number is {}", result);

    let char_list = vec!['y', 'm', 'a', 'q'];

    let result = largest(&char_list);
    println!("The largest char is {}", result);
}

运行后报错:

error[E0369]: binary operation `>` cannot be applied to type `T` // `>`操作符不能用于类型`T`
 --> src/main.rs:5:17
  |
5 |         if item > largest {
  |            ---- ^ ------- T
  |            |
  |            T
  |
help: consider restricting type parameter `T` // 考虑对T进行类型上的限制 :
  |
1 | fn largest<T: std::cmp::PartialOrd>(list: &[T]) -> T {
  |             ++++++++++++++++++++++

因为 T 可以是任何类型,但不是所有的类型都能进行比较,因此上面的错误中,编译器建议我们给 T 添加一个类型限制:使用 std::cmp::PartialOrd 特征(Trait)对 T 进行限制,特征在下一节会详细介绍,现在你只要理解,该特征的目的就是让类型实现可比较的功能。

结构体中使用泛型

结构体中的字段类型也可以用泛型来定义,下面代码定义了一个坐标点 Point,它可以存放任何类型的坐标值:

struct Point<T> {
    x: T,
    y: T,
}

fn main() {
    let integer = Point { x: 5, y: 10 };
    let float = Point { x: 1.0, y: 4.0 };
}

这里有两点需要特别的注意:

提前声明,跟泛型函数定义类似,首先我们在使用泛型参数之前必需要进行声明 Point<T>,接着就可以在结构体的字段类型中使用 T 来替代具体的类型
x 和 y 是相同的类型
第二点非常重要,如果使用不同的类型,那么它会导致下面代码的报错:

如果想让 x 和 y 既能类型相同,又能类型不同,就需要使用不同的泛型参数:

struct Point<T,U> {
    x: T,
    y: U,
}
fn main() {
    let p = Point{x: 1, y :1.1};
}

切记,所有的泛型参数都要提前声明.

枚举中使用泛型

提到枚举类型,Option 永远是第一个应该被想起来的,在之前的章节中,它也多次出现:

enum Option<T> {
    Some(T),
    None,
}

Option<T> 是一个拥有泛型 T 的枚举类型,它第一个成员是 Some(T),存放了一个类型为 T 的值。得益于泛型的引入,我们可以在任何一个需要返回值的函数中,去使用 Option<T> 枚举类型来做为返回值,用于返回一个任意类型的值 Some(T),或者没有值 None。

enum Result<T, E> {
    Ok(T),
    Err(E),
}

这个枚举和 Option 一样,主要用于函数返回值,与 Option 用于值的存在与否不同,Result 关注的主要是值的正确性。

如果函数正常运行,则最后返回一个 Ok(T),T 是函数具体的返回值类型,如果函数异常运行,则返回一个 Err(E),E 是错误类型。例如打开一个文件:如果成功打开文件,则返回 Ok(std::fs::File),因此 T 对应的是 std::fs::File 类型;而当打开文件时出现问题时,返回 Err(std::io::Error),E 对应的就是 std::io::Error 类型。

方法中使用泛型

方法上也可以使用泛型:

struct Point<T> {
    x: T,
    y: T,
}

impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}
fn main() {
    let p = Point { x: 5, y: 10 };

    println!("p.x = {}", p.x());
}

使用泛型参数前,依然需要提前声明:impl<T>,只有提前声明了,我们才能在Point&ltT>中使用它,这样 Rust 就知道 Point 的尖括号中的类型是泛型而不是具体类型。需要注意的是,这里的 Point&ltT> 不再是泛型声明,而是一个完整的结构体类型,因为我们定义的结构体就是 Point&ltT> 而不再是 Point。

除了结构体中的泛型参数,我们还能在该结构体的方法中定义额外的泛型参数,就跟泛型函数一样:

struct Point<T, U> {
    x: T,
    y: U,
}

impl<T, U> Point<T, U> {
    fn mixup<V, W>(self, other: Point<V, W>) -> Point<T, W> {
        Point {
            x: self.x,
            y: other.y,
        }
    }
}

fn main() {
    let p1 = Point { x: 5, y: 10.4 };
    let p2 = Point { x: "Hello", y: 'c'};

    let p3 = p1.mixup(p2);

    println!("p3.x = {}, p3.y = {}", p3.x, p3.y);
}

这个例子中,T,U 是定义在结构体 Point 上的泛型参数,V,W 是单独定义在方法 mixup 上的泛型参数,它们并不冲突,说白了,你可以理解为,一个是结构体泛型,一个是函数泛型。

为具体的泛型类型实现方法

对于 Point<T> 类型,你不仅能定义基于 T 的方法,还能针对特定的具体类型,进行方法定义:

impl Point<f32> {
    fn distance_from_origin(&self) -> f32 {
        (self.x.powi(2) + self.y.powi(2)).sqrt()
    }
}

这段代码意味着 Point<f32> 类型会有一个方法 distance_from_origin,而其他 T 不是 f32 类型的 Point<T> 实例则没有定义此方法。这个方法计算点实例与坐标(0.0, 0.0) 之间的距离,并使用了只能用于浮点型的数学运算符。

const 泛型

const 泛型,也就是针对值的泛型,正好可以用于处理数组长度的问题:

fn display_array<T: std::fmt::Debug, const N: usize>(arr: [T; N]) {
    println!("{:?}", arr);
}
fn main() {
    let arr: [i32; 3] = [1, 2, 3];
    display_array(arr);

    let arr: [i32; 2] = [1, 2];
    display_array(arr);
}

如上所示,我们定义了一个类型为 [T; N] 的数组,其中 T 是一个基于类型的泛型参数,这个和之前讲的泛型没有区别,而重点在于 N 这个泛型参数,它是一个基于值的泛型参数!因为它用来替代的是数组的长度。

N 就是 const 泛型,定义的语法是 const N: usize,表示 const 泛型 N ,它基于的值类型是 usize。

在泛型参数之前,Rust 完全不适合复杂矩阵的运算,自从有了 const 泛型,一切即将改变。

const 泛型表达式

假设我们某段代码需要在内存很小的平台上工作,因此需要限制函数参数占用的内存大小,此时就可以使用 const 泛型表达式来实现:

// 目前只能在nightly版本下使用
#![allow(incomplete_features)]
#![feature(generic_const_exprs)]

fn something<T>(val: T)
where
    Assert<{ core::mem::size_of::<T>() < 768 }>: IsTrue,
    //       ^-----------------------------^ 这里是一个 const 表达式,换成其它的 const 表达式也可以
{
    //
}

fn main() {
    something([0u8; 0]); // ok
    something([0u8; 512]); // ok
    something([0u8; 1024]); // 编译错误,数组长度是1024字节,超过了768字节的参数长度限制
}

// ---

pub enum Assert<const CHECK: bool> {
    //
}

pub trait IsTrue {
    //
}

impl IsTrue for Assert<true> {
    //
}
const fn
@todo
Rust学习教程24 - 泛型和const泛型 泛型Generics Go语言在2022年,就要正式引入泛型,被视为在1.0版本后,语言特性发展迈出的一大步,那么为什么泛型这么重要?到底什么是泛型?以及Rust的泛型又有几种? 本章将一一为你讲解。 我们在编程中,经常有这样的需求:用同一功能的函数处理不同类型的数据,例如两. 阅读详情

相关推荐

【Rust泛型】Rust泛型使用详解与应用场景

泛型(Generics)是一种编程语言特性,允许在编写代码时使用类型参数,这些参数可以在使用时被具体类型替换。Rust的泛型系统既强大又安全,能够在编译时检查所有类型约束。 泛型是一种参数化多态的形式,它允许你在定义函数、结构体、枚举和方法时使用类型参数,而不是具体的类型。

景天科技苑 4万+

Rust 泛型详解

Rust泛型详解:强大灵活的抽象工具 Rust泛型允许编写类型无关的通用代码,提升复用性和安全性。核心特性包括:泛型函数/结构体/枚举,通过<T>声明类型参数;trait约束使用where子句限制类型行为;性能优化通过编译时单态化实现零开销。const泛型支持基于常量值的特化,适用于数组等场景。高级用法涵盖关联类型和生命周期参数。最佳实践建议合理使用trait约束,避免过度泛型化。文中通过算术运算和Arduino的map函数实现展示了泛型的实际应用,体现了Rust在编译期保障类型安全的同时提供高

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

【Rust指南】泛型与特性

在上篇Rust 文章中涉及到了泛型的知识,那么今天就来详细介绍一下Rust 中的泛型与特性。泛型是一个编程语言不可或缺的机制,例如在C++ 语言中用模板来实现泛型。泛型机制是编程语言用于表达类型抽象的机制,一般用于功能确定、数据类型待定的类,如链表、映射表等。} i += 1;println!} //运行结果:max = 8这是一个简单的取最大值程序,可以用于处理i32数字类型的数据,但无法用于f64类型的数据。通过使用泛型} i += 1;实际上,并不是所有的数据类型都可以比大小。

叶落秋白的博客 2624

Rust编程的泛型

C/C++、Rust都是强类型语言,在对数据进行处理时,必须明确数据的数据类型。但是很多时候,比如链表这种数据结构,可以是整型数据的链表,也可以是其他类型,可能会写出重复的代码,只是数据类型不同而已。泛型编程是一种编程风格,其中的算法以尽可能抽象的方式编写,而不依赖于将在其上执行这些算法的数据形式。泛型这个词并不是通用的,在不同的语言实现中,具有不同的命名。

夏天又到了的专栏 1168

避坑指南:你的VASP CI-NEB计算为什么不收敛?常见错误分析与解决思路

本文深入解析VASP CI-NEB计算不收敛的常见问题,提供从结构准备到参数设置的系统解决方案。针对过渡态计算中的能量曲线异常、中间图像偏离等典型问题,详细介绍了诊断方法和实用工具,帮助研究者高效解决CI-NEB收敛难题,提升计算效率。

weixin_29698641的博客 435

MATLAB新手必看:5分钟搞定直流无刷电机Simulink仿真(附完整模型下载)

本文为MATLAB新手提供直流无刷电机Simulink仿真的快速入门指南,涵盖从环境配置到速度控制闭环实现的完整流程。通过详细的模块选择和参数设置说明,帮助读者5分钟内搭建基础仿真模型,并附赠完整模型下载,助力快速掌握电机控制仿真技术。

efc123456的博客 985

详解Rust泛型用法

Rust是一种系统编程语言,它拥有强大的泛型支持,泛型是Rust中用于实现代码复用和类型安全的重要特性。通过泛型程序员可以编写能够操作不同类型数据的函数、结构体、枚举和方法,同时又能确保类型安全,避免类型错误。在Rust中泛型的使用不仅能够提升代码的复用性,还能使得代码更加灵活,尤其是在实现与数据类型无关的算法时。

yang1fei2的博客 2180

TensorFlow GPU版本安装步骤-Windows系统

本文由在Windows下安装TensorFlow GPU版本教程-优快云等整理得到。 目录 1、确认显卡是否支持CUDA 1.1 查看显卡信息 打开“设备管理器”,查看显卡信息,如下图所示: 由上图知,本电脑的显卡为NVIDIA Quadro P400. 1.2 查看支持CUDA的显卡 网址:https://developer.nvidia.com/cuda-gpus 经查询可知,该显卡支持CUDA,如下图所示: 2、安装CUDA 2.1 下载CUDA 网址:https://developer.nvi

x_lingyun的专栏 766

rust 泛型、多态

无论是c++ STL还是rust std,里面所有的数据结构都是泛型的,c++和rust的结构体也类似,可以是泛型的也可以是非泛型的。所以,泛型函数内部对T的约束条件,都通过指明T所包含的trait的方式进行说明。Ord特征中并没有eq函数,但是Ord特征间接继承了PartialOrd,所以有Ord特征的类型肯定是可以使用==的。对于绝大部分trait,模板类型都是默认不包含该trait的,需要特征约束才能说明该类型具有该trait。作为泛型参数的常数类型,可以是所有整数类型、bool类型、char类型。

nameofcsdn的博客 2347

【抓包工具】Windows 10/11:Charles 从零到精通(下载、安装、配置与HTTPS证书实战)

本文提供了一份详尽的Charles抓包工具在Windows 10/11系统上的从零到精通指南。内容涵盖下载安装、初始配置、解决端口冲突,并重点解析了HTTPS抓包的核心步骤——安装CA证书。此外,还介绍了手机抓包配置及映射、断点等高效使用技巧,帮助开发者和测试人员快速掌握网络调试与安全分析技能。

weixin_29251131的博客 554

Solidworks钣金设计:折弯系数、K因子与折弯扣除的实战应用解析

本文深入解析Solidworks钣金设计中折弯系数、K因子与折弯扣除的核心概念与实战应用。通过厘清三者间的逻辑关系与换算方法,并结合材料特性、工艺参数及车间实测,指导工程师精准确定展开长度,确保设计图纸与加工实物的一致性,有效提升钣金件设计精度与生产效率。

weixin_29268267的博客 927

Rust泛型参数的使用

Rust的泛型系统是类型理论与系统编程实践的精妙结合。通过单态化实现零成本抽象,通过特征约束保证类型安全,通过生命周期泛型消除内存错误,通过关联类型简化复杂签名。掌握泛型参数的使用,意味着能够设计出既抽象又高效的API,在保持代码复用性的同时不牺牲性能。这正是Rust能够在系统编程领域独树一帜的核心原因——它证明了高层抽象与底层性能并非不可兼得。

2401_88292786的博客 2016

在ros里给机械臂加上夹爪和底盘后,控制真实机械臂

使用ur3_bringup 可以连接真实机械臂 使用官方的ur3_moveit_planning_execution.launch 可以对机械臂 moveit规划。 但是只有机械臂,没有夹爪。 官方如图: 我把原来的ur3_moveit_config 复制出来,修改 然后把ur3.xacro 等模型文件复制出来修改,修改完之后,有了夹爪,有了底盘。 规划组什么的使用moveit setup assistant 配置过了。 在rviz中可以笛卡尔空间规划了。 ...

超级菜 2721

Rust的泛型

文章目录Rust的泛型在函数中使用泛型特性与特性绑定在结构体中使用泛型 Rust的泛型 在函数中使用泛型 项目经理总是善变的,有一天项目经理告诉我,替客户计算一个圆形的面积。客户要求很简单,半径只会是u8类型。好,我写了如下代码: fn area_u8(r: u8) -> u8 { r * r } fn main() { println!("{}", area_u8(3)); } 可第二天项目经理又来了,说客户说的不对,半径某种情况下还会是u16。唉,客户就是上帝,项目经理也没有办

鸿鹄之志 4210

非机动车闯红灯检测与自动录像系统实战(YOLO+追踪+红绿灯感知)

本文聚焦非机动车(如电动车、自行车)闯红灯行为的智能识别系统构建,结合 YOLO 检测模型、追踪算法(如 DeepSORT)、红绿灯状态感知与区域判断逻辑,构建完整的违章行为识别与证据录像系统。文章涵盖数据采集、模型选型、红绿灯触发机制、闯红逻辑判定、视频自动保存等核心环节,辅以 Jetson/RK3588 平台部署与工程实测,适用于城市交通监控、智慧路口管控等真实场景。

努力分享一些人工智能、计算机视觉、影像等相关的知识干货! 1285

Sprd Android 13 备忘 OTA升级app没更新到目标版本,恢复出厂才生效修改这个值

【代码】Sprd Android 13 备忘 OTA升级app没更新到目标版本,恢复出厂才生效修改这个值。

m0_60898338的博客 680

【Rust自学】10.2. 泛型

泛型的主要功能是提高代码的复用能力,适用于处理重复代码的问题,也可以说是实现数据与算法的分离。泛型是具体类型或其它属性的抽象代替。它的意思是你写代码时写的泛型代码并不是最终的代码,而是一种模版,里面有一些“占位符”。

A Rookie in San Domenico School 1508

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

rust泛型

RHS=Self,Self就是泛型参数默认值,它表示实现Add的类型,在这里就是Point类型。如果实现Add时不指定RHS的具体类型,RHS的类型将是Self类型。方法mixup将一个Point点的x与Point点的y融合成一个类型为Point的新点。单态化是一个通过填充编译时使用的具体类型,将通用代码转换为特定代码的过程。在编译期,会根据指定的具体类型,生成一套特化代码,这叫单态化。展开为两个针对i32和f64的定义,接着将泛型定义替换为这两个具体的定义。

void的博客 1557

最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版

Part-E1-SDIO-Specification-Ver4.00-Final-120220.pdf:最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版,包括SDIO 接口的外设,SDIO 接口官方协议等。

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

Rust:泛型

讲解Rust的泛型,单态化机制,const泛型

博客网站 https://async-area.com 957

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

Rust泛型详解

泛型可以看作构建函数和类型定义的模板。标准库中有很多常见类型例如Option<T>Vec<T>等都是泛型实现的。主要用于代码的特化。Rust是静态类型语言,因此泛型的类型参数(T)需要在编译期解析为具体类型,这种特性就是参数化多态性。泛型的实现还采用单态化技术,会根据实际传入的类型参数,将泛型实例化为唯一的专用类型。

Hello World! 989

Rust 语言特性:泛型

本文介绍了Rust中泛型的使用方式。首先展示了在函数中使用泛型实现最大值查找功能,通过<T: PartialOrd + Copy>限定类型范围。其次说明了结构体中的泛型应用,支持单类型或多类型参数。然后回顾了枚举中使用泛型的典型例子Option<T>。接着讲解了方法中的泛型实现,包括结构体泛型与方法泛型的关联使用。最后解释了Rust采用"单态化"实现泛型,通过编译器为每种具体类型生成专门代码,确保零性能损失。全文通过代码示例详细说明了Rust泛型在不同场景下的应用

Laurence的技术博客 923

《Rust语言圣经》Rust教程笔记21:2.Rust基础入门(2.8泛型和特征)2.8.1Rust泛型(结构体泛型、枚举泛型、方法泛型、const泛型(常量泛型)、const fn常量函数)泛型性能

Tconst关键字是为了让 Rust 编译器能够在编译时处理数组的大小,使得数组大小成为类型的一部分,并且能够优化代码。没有const,Rust 就无法在编译时知道数组的大小,也无法利用数组大小进行优化。因此,const N是定义常量泛型的一部分,用来确保 Rust 在编译时知道并使用数组的大小。

Dontla的博客 1677

Rust 泛型与特性

泛型是一个编程语言不可或缺的机制。C++ 语言中用"模板"来实现泛型,而 C 语言中没有泛型的机制,这也导致 C 语言难以构建类型复杂的工程。泛型机制是编程语言用于表达类型抽象的机制,一般用于功能确定、数据类型待定的类,如链表、映射表等。这是一个对整型数字选择排序的方法:fn max(array: &[i32]) -> i32 { let mut max_index = 0; let mut i = 1; while i < array.len() { if arra

m0_65541699的博客 1708

Rust 中的泛型

数据类型是对同一类数据的抽象,而泛型是对具有一组相同行为的数据类型的抽象。Rust 使用 trait 来描述这一组相同的行为,简单的说 trait 就是一组函数的集合。Rust中的trait类似于其他语言中的常被称为接口(interfaces)的功能。 泛型 在函数中使用泛型 假如有两个函数,它们的功能是查找slice中最大值并返回,函数体中的采用的算法是一样的,主要不同的是参数类型。如下所示: fn largest_i32(list: &[i32]) -> i32 { let mut

花落花开的博客 1420

30天拿下Rust之泛型

在Rust语言中,泛型是一种强大的工具,它允许我们编写可复用且灵活的代码。通过泛型,我们可以创建适用于多种类型的数据结构和函数,而无需为每种类型都重复编写相同的逻辑。在Rust中,泛型通过指定类型参数来实现,这些类型参数会在编译时被具体类型所替换。

hope_wisdom的技术博客 1913

【Rust中的泛型与特征(一)】

泛型的本质是类型的参数化,允许在定义类、接口、方法时使用类型形参,当使用时指定具体类型,所有使用该泛型参数的地方都被统一化,保证类型一致。

m0_37719524的博客 1110
上一篇: Rust错误处理
下一篇: MyBatis-Plus 实战教程一 快速入门
过去日记
过去日记 新星创作者: 后端开发技术领域 新星创作者: 后端开发技术领域
博客等级 码龄3年 5343粉丝 225原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

过去日记

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

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

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

打赏作者

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

抵扣说明:

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

余额充值