Rust 字符串与切片实战

C++与Rust安全互操作:FFI/ABI原理与5大实战模式详解 在系统级编程中,外部函数接口(FFI)是实现不同编程语言间互操作的核心机制,它定义了函数调用、参数传递和内存布局等底层约定。其原理基于应用二进制接口(ABI)这一二进制层面的交互标准,确保跨语言调用时数据表示和函数调用约定的一致性。这一技术的核心价值在于,它允许开发者复用现有代码库,同时引入更安全的编程范式,从而在保持高性能的前提下提升系统可靠性。典型的应用场景包括游戏引擎、高频交易系统、嵌入式驱动等对性能和安全性均有严苛要求的领域。本文聚焦于C++与Rust这两种高性能系统语言的互操作,深入剖析了通过类型 阅读详情

Rust 字符串与切片实战

字符串与切片是所有新手遇到的第一个门槛,不同于 Java、Python 等语言对字符串的高度封装,Rust 的字符串与切片深度绑定了所有权、借用、生命周期与 UTF-8 编码,从编译期就将乱码、内存安全等问题解决。

什么是切片(Slice)

字符串是切片的特殊场景,想要理解字符串,必须先搞懂切片。在 Rust 里,切片是描述一组属于同一类型、长度不确定的、在内存中连续存放的数据结构,用 [T] 来表述。因为长度不确定,切片属于动态大小类型(DST, Dynamically Sized Type),无法直接在栈上存储,必须通过引用(&[T],不可变切片)或可变引用(&mut [T],可变切片)来使用。

切片通过 Rust 的范围语法 [start..end] 创建,遵循左闭右开原则,支持多种简写形式:

  • [a..b]:从索引 a 到 b-1 的切片
  • [a..]:从索引 a 到集合末尾的切片
  • [..b]:从集合开头到索引 b-1 的切片
  • [..]:覆盖整个集合的全切片

示例如下:

fn main() {
    // 原数组:切片的底层数据所有者
    let arr = [1, 2, 3, 4, 5];
    
    // 创建切片:引用数组的第1到第3个元素
    let slice: &[i32] = &arr[1..4];
    println!("切片内容: {:?}", slice); // 输出 [2, 3, 4]
    println!("切片长度: {}", slice.len()); // 输出 3
    println!("切片是否为空: {}", slice.is_empty()); // 输出 false
}

Rust 的切片从编译期就杜绝了两类经典内存问题:

  1. 越界访问:编译期会校验切片范围,运行时也会做边界检查,直接拒绝非法访问
  2. 悬垂引用:生命周期规则保证,只要切片有效,底层数据的所有者就一定不会被释放或修改

示例如下:

// 获取数组中第一个非零元素的切片
fn first_non_zero(arr: &[i32]) -> &[i32] {
    for (i, &num) in arr.iter().enumerate() {
        if num != 0 {
            return &arr[i..];
        }
    }
    &arr[..0]
}

fn main() {
    let arr = [0, 0, 3, 5, 7];
    let non_zero_slice = first_non_zero(&arr);
    
    // 编译报错:无法修改原数组,因为它已经被切片借用
    // arr[2] = 0;
    
    println!("非零切片: {:?}", non_zero_slice); // 输出 [3, 5, 7]
}

这个例子体现了 Rust 的安全哲学:在切片的生命周期内,原数据无法被修改,彻底避免了数据竞争与悬垂引用。

Rust 字符串的两大核心类型

Rust 的字符串体系看似复杂,核心只有两个类型,其他都是面向特定场景的扩展:

  • &str:字符串切片,无所有权,只读,是切片的 UTF-8 版本
  • String:可拥有、可修改的字符串类型,底层是堆上分配的 Vec<u8> 封装

两者的关系如同 &[T] 与 Vec<T>:&str 是数据的“视图”,String 是数据的“所有者”。

Rust 字符串的核心设计:强制 UTF-8 编码

很多新手可能会困惑为什么 Python、Go 可以直接用索引 s[i] 取字符,而 Rust 却不行?原因在于:Rust 的字符串强制使用 UTF-8 编码,而 UTF-8 是变长编码。

  • ASCII 字符占 1 个字节
  • 中文、日文等东亚字符占 3 个字节
  • Emoji 等特殊字符占 4 个字节

如果允许直接按索引访问,会带来两个致命问题:

  • 索引访问的时间复杂度不再是 O(1),必须遍历字符串才能定位到对应字符
  • 极易访问到字符的中间字节,生成非法 UTF-8 序列,引发未定义行为(UB)

因此 Rust 从语法层面禁止了直接通过索引访问字符串字符,只允许通过合法的方式遍历和操作。

字节与字符的正确操作

fn main() {
    let s = "你好Rust";
    println!("字节长度: {}", s.len()); // 输出 10(2个中文*3字节 + 4个ASCII字符=10)
    println!("字符数量: {}", s.chars().count()); // 输出 6
    
    // 正确方式1:遍历所有字符(Unicode标量值)
    println!("=== 字符遍历 ===");
    for c in s.chars() {
        println!("字符: {}", c);
    }
    
    // 正确方式2:遍历所有字节
    println!("=== 字节遍历 ===");
    for b in s.bytes() {
        println!("字节: {}", b);
    }
}

字符串切片的致命坑:字符边界问题

Rust 编译期不会检查切片范围是否符合 UTF-8 字符边界,只有运行时会校验,一旦切到字符中间,会直接触发 panic。

fn main() {
    let s = "你好";
    // 反例:运行时 panic!"你"占3个字节,[0..2]切到了字符中间
    // let sub = &s[0..2];
    
    // 正确示例:严格按字符边界切片
    let sub = &s[0..3];
    println!("{}", sub); // 输出 你
}

所以在实际开发中最佳实践是:不要硬编码索引切片字符串,优先通过 chars().enumerate() 定位字符位置,再进行切片操作。

字符串与切片的实战常用操作

String 的修改操作(仅所有者可用)

只有持有所有权的 String 可以修改内容,常用方法如下:

fn main() {
    let mut s = String::from("Hello");

    // 追加字符串切片
    s.push_str(" World");
    // 追加单个字符
    s.push('!');
    println!("{}", s); // 输出 Hello World!

    // 插入字符
    s.insert(5, ',');
    println!("{}", s); // 输出 Hello, World!

    // 弹出最后一个字符
    let last_char = s.pop();
    println!("弹出的字符: {:?}", last_char); // 输出 Some('!')

    // 清空字符串
    s.clear();
    println!("清空后是否为空: {}", s.is_empty()); // 输出 true
}

字符串拼接的三种方式与选型

方法用法所有权影响适用场景
+ 运算符String + &str左侧 String 所有权被转移简单拼接,无需保留原 String
format! 宏format!("{} {}", a, b)不转移任何所有权复杂拼接、多变量拼接,可读性优先
push_str 方法s.push_str(&str)仅修改原 String,不转移循环追加、动态构建字符串

示例如下:

fn main() {
    let s1 = String::from("Hello");
    let s2 = "Rust";

    // + 运算符:s1所有权被转移,后续无法使用
    let s3 = s1 + " " + s2;
    println!("+ 拼接结果: {}", s3); // 输出 Hello Rust

    // format! 宏:不转移所有权,最灵活
    let a = String::from("你好");
    let b = String::from("世界");
    let c = format!("{},{}!", a, b);
    println!("format! 结果: {}", c); // 输出 你好,世界!
    println!("a仍可用: {}", a); // 所有权未转移,可正常使用
}

字符串切片的常用工具方法

fn main() {
    let s = "  Hello Rust  ";

    // 去除首尾空白
    println!("trim后: '{}'", s.trim()); // 输出 'Hello Rust'

    // 前缀/后缀判断
    let trimmed = s.trim();
    println!("是否以Hello开头: {}", trimmed.starts_with("Hello")); // 输出 true
    println!("是否以Rust结尾: {}", trimmed.ends_with("Rust")); // 输出 true

    // 包含判断与查找
    println!("是否包含Rust: {}", s.contains("Rust")); // 输出 true
    println!("Rust的起始位置: {:?}", s.find("Rust")); // 输出 Some(8)

    // 分割字符串
    let parts: Vec<&str> = trimmed.split_whitespace().collect();
    println!("分割结果: {:?}", parts); // 输出 ["Hello", "Rust"]
}

最常用的转换:String 与 & str 的互转

Rust 提供了非常便捷的转换能力,核心是 Deref 强制转换机制:&String 可以自动被编译器转换为 &str,无需手动处理。

这也是实际开发中的一个最佳实践:函数参数优先使用 &str,而非 &String。因为 &str 可以同时接受字符串字面量、&String、其他字符串切片,通用性最大。

// 函数参数使用&str,获得最大通用性
fn print_info(s: &str) {
    println!("内容: {},字节长度: {}", s, s.len());
}

fn main() {
    let s = String::from("Hello Rust");
    
    // 直接传&String,自动转换为&str
    print_info(&s);
    
    // 传字符串字面量,完全兼容
    print_info("你好世界");
    
    // 手动创建全切片,效果完全一致
    print_info(&s[..]);
}

扩展:其他字符串相关类型

除了核心的 &str 和 String,Rust 标准库还提供了面向特定场景的字符串类型,无需深入学习,了解其用途即可:

  • OsStr/OsString:操作系统兼容的字符串,支持非 UTF-8 的路径、系统参数,位于 std::ffi 模块
  • CStr/CString:与 C 语言交互的字符串,以 \0 结尾,符合 C 语言字符串规范,位于 std::ffi 模块
  • Path/PathBuf:路径专用类型,基于 OsStr 封装,提供路径相关的专用方法,位于 std::path 模块

总结

Rust 的字符串与切片设计,看似严苛,实则是围绕内存安全、UTF-8 原生支持和零成本抽象三个核心目标,它把其他语言中运行时才会暴露的字符串乱码、越界、悬垂引用等问题,提前到了编译期解决。

理解这些设计背后的逻辑,你就能真正掌握 Rust 字符串与切片,写出既安全又高效的代码。

Rust学习教程12 - String字符串与切片 字符串 在其他语言,字符串往往是送分题,因为实在是太简单了,例如"hello, world"就是字符串章节的几乎全部内容了,对吧?如果你带着这样的想法来学Rust, 我保证,绝对会栽跟头,因此这一章大家一定要重视,仔细阅读,这里有很多其它Rust书籍中没有的内容。. 阅读详情

相关推荐

【Rust指南】结合String深入理解Rust语言的Slice(切片)类型

书接上文,本篇博客将通过结合有关字符串的Rust案例来深入理解并掌握Slice类型。旨在精准的学会切片类型的创建、作为函数的参数以及返回值以及语法糖的扩展等,同时也会分享到其他数据类型的切片,例如数组。

叶落秋白的博客 2814

Rust字符串String方法总结--课后习题

代码主要来源:Rust圣经 与 课后习题

Crookiebird的博客 507

【没有网络,安装python包】如何从 PyPI 下载并安装 Plotly 的离线包

在某些情况下,您可能需要在没有互联网连接的环境中安装 Python 包,例如在飞机上、在某些受限制的网络环境中或在需要离线安装的场景下。以下是如何在 PyPI(Python Package Index)下载 Plotly 包并进行离线安装的详细步骤。

赖德发的博客 1105

Rust 切片(Slice)实战详解:从数组借用、字符串切片到 Deref 强转,基于 rust-by-practice 六道练习题吃透 &[T] 与 &str

切片(Slice)是 Rust 复合类型中的核心概念:它允许你**借用**数组或字符串中一段连续的元素,而不发生所有权转移。本篇文章以 rust-by-practice 仓库中 [slice.md](https://link.gitcode.com/i/150f19641b887a2a0d2e173809433243) 的六道练习题为主线,结合 [英文练习原文](https://link.gitc

gitblog_01043的博客 651

深入SVT SPI VIP配置:如何灵活控制CS间隔、数据帧大小与时钟频率(含代码片段)

本文深入探讨了SVT SPI VIP的高级配置技巧,包括精确控制CS信号间隔、突破数据帧大小限制以及动态时钟频率切换。通过实战代码片段和详细配置步骤,帮助验证工程师灵活应对复杂SPI协议验证场景,提升验证效率和覆盖率。特别适合需要处理非标准SPI时序和特殊数据帧的芯片验证项目。

weixin_27014595的博客 284

是德频谱分析仪相位噪声测量实战指南:从原理到精准操作

本文详细介绍了是德频谱分析仪在相位噪声测量中的实战操作指南,从基础概念到高级技巧全面解析。通过5G基站时钟测量等实际案例,展示如何利用是德N9030B等设备精准测量相位噪声,并分享设备预热、参数设置、环境干扰排除等关键操作要点,帮助工程师提升测量精度和效率。

jenkins8butler的博客 230

Rust四大复合类型详解:数组、元组、切片、字符串实战指南

Rust语言以严格的所有权与借用机制著称,其中复合类型是构建真实数据结构的基础。数组(array)提供定长同构数据的栈上存储,元组(tuple)允许异构数据打包,切片(slice)作为连续内存的借用视图,字符串(String/&str)则承载UTF-8编码文本。理解这些类型的内存布局、所有权语义及转换规则,是写出高效安全Rust代码的关键。在系统编程、Web后端和高性能服务中,合理选择复合类型能显著减少不必要的堆分配和拷贝,并规避因边界与编码引发的运行期错误。从函数参数设计到字符串处理,处处体现Rust对安

weixin_42542669的博客 230

微信H5网页授权通用方案:中转页破解域名限制,适配Hash/History路由

在Web开发中,OAuth 2.0授权码模式是实现第三方登录的通用标准,其核心原理是通过授权服务器颁发临时代码,再由客户端交换访问令牌。这一机制在微信公众号H5开发中尤为重要,用于安全获取用户身份。然而,微信平台对网页授权回调域名有严格的数量限制,这成为多子域名、多环境及微前端架构下业务扩展的主要瓶颈。其技术价值在于通过设计一个统一的中转授权页,将授权逻辑与业务逻辑解耦,让所有业务页面共享一个已配置的授权入口,从而突破域名配额限制。该方案的关键在于适配不同的前端路由模式,需精准处理Hash模式与Histor

weixin_42533120的博客 324

【Rust编程:从小白入坑】Rust切片(Slice)类型详解

本文介绍了Rust中的切片(Slice)概念,重点讲解了字符串切片(&str)的使用。主要内容包括:1)切片的基础语法和范围表示方法;2)字符串切片的安全优势,通过first_word示例展示了如何避免数据不同步问题;3)字符串分割等实战应用;4)String与&str的类型区别及最佳实践,建议函数参数优先使用&str;5)数组切片的基本语法。切片作为Rust的核心特性之一,提供了安全高效的数据访问方式,避免了索引越界和内存安全问题。文章还对比了String和&str的相互转

小淼淼的博客 416

Excel转LaTeX表格神器:excel2latex.xla插件使用全攻略(含下载链接与配置教程)

本文详细介绍了Excel转LaTeX表格神器excel2latex.xla插件的完整使用攻略。从下载安装、基础转换到高级配置,深入讲解了如何利用该插件高效生成LaTeX代码,特别针对IEEE双栏等复杂排版需求提供了专业解决方案,帮助用户彻底告别手动编码,提升学术与专业文档的排版效率。

app77的博客 298

【100%通过率】华为od机试C卷【部门人力分配】Python 实现

当前部门需要完成 N 个需求,需求用 requirements[i] 表示,requirements[i] 表示第 i 个需求的工作量大小,单位:人月。2:明显这个人力需求值有上下限的情况下【下限为requirements中的最大值,上限为requirements中的最大两个值相加(因为最多有两个需求同一个月开发)】,可以考虑使用二分法。当选择人力为6时,2个需求量为3的工作可以在1个月里完成,其他2个工作各需要1个月完成。当选择人力为5时,4个工作各需要1个月完成,一共需要4个月才能完成所有需求。

MISAYAONE的博客 2020

【Rust编程:从小白入坑】Rust字符串详解

Rust字符串处理指南 Rust提供了两种主要字符串类型:String(可变的、拥有所有权的UTF-8字符串)和&str(不可变字符串切片)。本文介绍了字符串的基本创建方法(String::from()、to_string()等)、常用操作(追加、拼接、替换、删除等)以及字符串切片的使用注意事项(需遵循UTF-8边界)。此外,还讲解了字符串遍历方法(按字符、字节或带索引遍历)和常用查询方法(长度、包含、查找等)。Rust的字符串处理虽然相对复杂,但提供了强大的安全保证,特别是对UTF-8编码的严格处

小淼淼的博客 535

【HALCON工业视觉应用探索】02. C# + Halcon铸件毛刺机器人打磨引导:点云处理从实验室到工业现场的全流程落地

摘要:铸件毛刺的自动化打磨是机械制造领域的重要难题,其随机性(高度0.1-3mm)和复杂工况导致人工打磨效率低(3分钟/件)、工伤率高。本文基于Halcon 24.11与.NET 6,构建了一套点云处理方案:通过线激光扫描仪获取三维点云,经预处理、毛刺检测、路径规划三大模块,引导机器人完成打磨。虚拟实验测试显示,对高度>1mm的毛刺检出率达100%,定位误差±0.08mm,但工业现场受油污、粉尘影响,性能降至检出率68-75%、处理时间>45秒。

专注于人工智能、软件开发、工控自动化、工厂数字化及智能化等领域,希望和大家共同进步! 1129

Rust 字符串全解:rust-by-practice 复合类型 String 章节实战与源码解析

字符串是 Rust 中最常用也最容易踩坑的复合类型之一:`str`、`&str`、`String` 三者关系、UTF-8 编码、转义与切片边界问题,几乎困扰每一位初学者。本篇以 rust-by-practice 仓库中 [en/src/compound-types/string.md](https://link.gitcode.com/i/7a90279ddbd06d525f0fd6a58795f

gitblog_00814的博客 490

SimpleITK使用——1. 进行Resample/Resize操作

文章目录1. 变换到一个新的spacing1.1 使用Resample()的方法1.1.1 完整代码1.1.2 转换前后图像1.2 使用ResampleImageFilter()的方法2. 已知原图和变换后目标图像的大小2.1 代码2.2 转换后图像3. 相关内容说明3.0 体素和spacing3.1 Resample() 函数说明3.2 itk::simple::ResampleImageFilter函数说明 1. 变换到一个新的spacing 1.1 使用Resample()的方法 1.1.1

啷个哩个啷 8081

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

Rust专项——实战:字符串与集合的所有权/借用/生命周期模型

本文总结了Rust中所有权、借用和生命周期在字符串、向量和哈希表等数据结构中的应用实践。文章提出了"参数借用+返回所有权/视图"的设计模式:函数参数优先使用&str/&[T]等借用类型,需要所有权时在边界处转换;返回值根据使用场景选择拥有所有权(String/Vec)或视图(&str/&[T])。文章通过多个示例展示了该模式在API设计中的具体应用,并总结了常见错误的修复方法,包括所有权转移、借用冲突和临时值引用等问题。最后提供了两个实战练习,帮助读者掌握

红目香薰 911

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

Rust bstr库实战:高效处理非UTF-8字节字符串

字符串编码是软件开发中绕不开的基础问题,尤其在处理日志文件、网络协议、遗留系统编码和二进制格式时,数据往往并非合法 UTF-8。Rust 标准库的 String 和 &str 强制要求 UTF-8,虽然带来了安全性,却让包含 0xFF 或 GBK 字节的数据难以直接处理。bstr crate 为此引入了 BString 和 BStr 字节字符串类型,它们不验证 UTF-8,可保存任意字节,同时提供查找、切片、替换、按行读取等类似标准库的方法。这种设计让开发者能在保留原始字节的前提下,灵活操作半文本半二进制数

weixin_34094282的博客 284

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

Rust复合类型 四大军阀:数、元、切、串

掌握这四种类型的特性、用法及相互配合,能为后续Rust编程(如集合、结构体、函数开发)打下坚实基础

码刀攻城 1219

Rust 练习册 :字符串序列切片的艺术

本文探讨了如何从数字字符串中提取指定长度的连续子串问题。通过Rust实现,分析了多种边界情况(如长度为0、超长等情况)的处理方法。文章展示了基本实现和优化版本(使用windows迭代器),并讨论了性能考虑、错误处理等实际应用问题。这一字符串处理问题虽然简单,但涉及迭代器、集合操作、函数式编程等Rust核心概念,在数据分析、生物信息学等领域有广泛应用价值。解决方案体现了Rust在字符串处理和性能优化方面的优势。

weixin_44540743的博客 837

c++ string 最后一个字符_一起学Rust编程「8」:字符串和切片

我们已经见过了Rust的动态字符串String类型:let mut a = String::from("hello");a.push_str(" world");今天再借LeetCode的题来了解一下字符串的常用操作——切片。对String来说,切片是一种引用形式的子串,所以它的效率很高。我们先看题目:58. 最后一个单词的长度给定一个仅包含大小写字母和空格 ' ' 的字符串 s,返回其最后一个单...

weixin_39714565的博客 192

Rust 练习册 101:字符串序列切片的艺术

本文探讨了如何在Rust中从数字字符串提取指定长度的连续子串。通过实现series函数,演示了处理边界条件(如长度为0或大于字符串长度)的方法。文章比较了两种实现方式:基础版本使用字符向量和切片操作,优化版本则利用Rust的windows迭代器使代码更简洁。解决方案涉及了Rust核心特性如迭代器、切片、函数式编程等,并讨论了在数据分析、生物信息学等领域的应用场景。最后还提出了性能优化思路和错误处理实践,展示了Rust处理字符串和集合类型的灵活性。

少湖说 1154

Rust所有权机制解析:内存安全与高效编程

内存管理是现代编程语言的核心课题,Rust通过独特的所有权系统在编译期保障内存安全。该机制基于三大原则:每个值有唯一所有者、所有权可转移、引用需明确生命周期。相比GC语言的运行时开销和C++的手动管理,Rust在编译阶段就杜绝了悬垂指针和数据竞争等问题。在字符串处理、结构体设计和多线程编程等场景中,所有权机制配合借用检查器能有效预防常见内存错误。通过Rc/RefCell等智能指针,开发者还能灵活处理循环引用等特殊需求。这套系统使Rust兼具C++的性能优势和GC语言的安全性,特别适合系统编程和高并发场景。

weixin_30225755的博客 95

深入Rust Serde:掌握Deserialize特质与Visitor模式实现高效反序列化

序列化与反序列化是数据交换和持久化的基础技术,其核心原理在于将内存中的数据结构转换为可传输或存储的字节序列,并在需要时重建。在Rust生态中,Serde库通过零成本抽象实现了高性能的序列化框架,其关键技术之一便是访问者(Visitor)模式。该模式将数据结构的遍历与构建逻辑分离,允许反序列化器(Deserializer)驱动用户定义的Visitor来逐步构建目标类型,从而在JSON、TOML、YAML等多种格式间实现灵活映射。这种设计不仅提升了代码的复用性和扩展性,更在性能敏感场景下支持零拷贝(Zero-C

weixin_33980459的博客 392

Rust 字符串与切片

指向自身(Python 中的 self,Java 中的 this),也就是说该函数的作用是:在原字符串 s1 上追加 s2,最后得到一个新的字符串。源码可以发现,String 字符串的底层采用的是一个 u8 容器。由于 Rust 的底层是一个字节数组,而非字符,没法绝对准确的确保边界,所以没办法很方便的得到字符串的子串。字符串切片是切割的字节数组,采用的 UTF-8 编码,所以需要额外小心使得切割的边界要保证恰好落在边界上。这个函数,而该函数的第二个参数是字符串切片类型,因此必须要保证。

XiaoLing 一直摆烂哇! 1345

rust-切片类型

所有权、借用以及 Slice 概念共同保证 Rust 程序内存安全并发生于编译期控制之下。Rust 提供系统级语言般精细内存管理能力,但拥有者离开作用域时自动释放资源,无需手动写复杂销毁代码,从而减少调试负担。所有权机制贯穿 Rust 多处设计理念,全书后续章节将持续深入探讨。本章至此结束,我们接下来进入第五章学习如何通过结构体(struct)组合数据块吧!

qq_29372275的博客 1182
上一篇: 通过示例学习 Rust 模式匹配
下一篇: 构建可扩展 Rust 项目:从模块化到 Workspace 工程化实践
Rust研习社
博客等级 码龄11年 52粉丝 84原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值