Rust常用数据结构教程 String与&str，元组和数组

2024-11-07 17:08:38

文章目录

一、String与&str
- 1.Rust中的字符串
- 2.String与&str的区别
- 3.Vec源码
- 4. str与&str
- 5.&str与String的区别总结
- 6.什么时候用String、什么时候用&str
- 7.Example
二、元组与数组
参考

一、String与&str

Rust中String的源码

#[derive(PartialEq, PartialOrd, Eq, Ord)]
#[stable(feature = "rust1", since = "1.0.0")]
#[cfg_attr(not(test), lang = "String")]
pub struct String {
vec: Vec<u8>,
}

我们可以看到String是一个结构体
· Vec<u8>
·Vec可变数组，具体内容会在第三章
·u8是无符号整数类型，可以表示0-255之间的数

如何从01到字符串
·0101100110011010 10101001 10101011 10110110=>“原子之音"
需要解决两个问题
·需要知道何时结束

一种是存储结束符
一种是在开始存储len

如何编码，最常用的编码方式

ASCII一个字节对应一个字符（可以表示0-255个字符）
UTF-8一个到四个字节对应（可以辨识所有语言的字符，除了私人语言，而且可以兼容ASCII）

注：一个字节8位，大家知道为啥String内置u8的可变数组（Vec）

1.Rust中的字符串

·选择在开始长度存储
·所有的string都是utf-8
·字符串默认不可变

2.String与&str的区别

·String是结构体而&str是切片的引用
·从实体上讲String类型与str类型，因为&str没有所有权

String

string_item
pointer:0x213342312c011 —>指向heap中的头一个字符的地址,如"hello""h’,‘e’, “I’… 中的h
length:3 具体个数
Capacity:10 扩容一般翻倍

3.Vec源码

pub struct Vec<T, #[unstable(feature = "allocator_api'", issue = "32838")] A:Alocator=Global>
{
buf: RawVec<T, A>,
len: usize, //长度
}


pub(crate) struct RawVec<T, A: Allocator = Global> {
ptr: Unique<T>, // 指向
cap: usize, // capacity
alloc: A,
}

4. str与&str

·一个不应存在的数据类型:切片(Rust看来)
·str就是字符串切片，就是数组切片[u8]，就是动态大小的utf8字节
·str在Rust是无法直接使用的，我们经常使用&str

Box<str>
Rc<str>
Arc<str>

Example：

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

    // 切片引用就是不可变引用，不可变引用和可变引用是互斥的
    let word = first_word(&s);

    s.clear();

    println!("The first word is: {}", word);
}

fn first_word(s: &str) -> &str {
    let all_bytes = s.as_bytes();

    for (i, &byte) in all_bytes.iter().enumerate() {
        if byte == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

编译及测试：

 cargo run
   Compiling project v0.1.0 (/home/wangji/installer/rust/project/ch1_variables)
error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable
 --> src/main.rs:6:5
  |
4 |     let word = first_word(&s);
  |                           -- immutable borrow occurs here
5 |
6 |     s.clear();
  |     ^^^^^^^^^ mutable borrow occurs here
7 |
8 |     println!("The first word is: {}", word);
  |                                       ---- immutable borrow later used here

For more information about this error, try `rustc --explain E0502`.
error: could not compile `project` (bin "project") due to 1 previous error

5.&str与String的区别总结

·String具有所有权，而&str只是切片引用
·String的数据必须存储在heap上，而&str要看引用所代指可以在stack和data section上，也可以在heap上

6.什么时候用String、什么时候用&str

. String

创建需要所有权的字符，有修改需求的

&str

查找，只读

7.Example

String与&str的区别，与相互转换
如何通过&[u8]转换为String
&str与生命周期

fn rust_say() -> &'static str {
    r#"Rust said "str" is danger"#
}

// &[u8] u8数组的切片引用
// 调用第三库 &[u8] -> String
fn u8_to_string(string_data: &[u8]) -> String {
    // String::from_utf8_lossy(string_data).to_string()
    // 在迭代器中使用 &s，意味着对 &u8 引用进行解引用，获取 u8 的值，
    // string_data.iter().map(|&s| s as char).collect()
    string_data.iter().map(|&s| s as char).collect()
}

fn main() {
    // string &str
    // 创建容量为0的空字符串
    let mut item = String::new();
    println!("String {}: cap {}", item, item.capacity());
    item.push('c');
    println!("String {}: cap {}", item, item.capacity());

    // 创建容量为10的空字符串
    let item = String::with_capacity(10);
    println!("String {}: cap {}", item, item.capacity());

    // &str-> String
    let item = String::from("hello world");
    println!("String {}: cap {}", item, item.capacity());
    let item = "hello world".to_string();
    println!("String {}: cap {}", item, item.capacity());

    // Sting->&str
    let i = &item; //&item的类型就是 &str

    // static'str
    println!("{}", rust_say());
    // 创建&str的两种方法：
    const C_S: &str = "";
    let yzzy = "yzzy";

    // &str => &u8
    println!("u8 to String: {}", u8_to_string(yzzy.as_bytes()));

    // &u8的打印
    for item in yzzy.as_bytes() {
        println!("item {}", item);
    }
}

编译及运行

 cargo run 
warning: unused variable: `i`
  --> src/main.rs:31:9
   |
31 |     let i = &item; //&item的类型就是 &str
   |         ^ help: if this is intentional, prefix it with an underscore: `_i`
   |
   = note: `#[warn(unused_variables)]` on by default

warning: constant `C_S` is never used
  --> src/main.rs:36:11
   |
36 |     const C_S: &str = "";
   |           ^^^
   |
   = note: `#[warn(dead_code)]` on by default

warning: `data_struct` (bin "data_struct") generated 2 warnings
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.00s
     Running `target/debug/data_struct`
String : cap 0
String c: cap 8
String : cap 10
String hello world: cap 11
String hello world: cap 11
Rust said "str" is danger
u8 to String: yzzy
item 121
item 122
item 122
item 121

二、元组与数组

元组与数组都是有所有权的数据类型

元组与数组都属于序列类型的复合结构

·元组

可以包含各种类型值的组合

数组

包含同一类型的数据组合

数组注意和切片的关系

fn u8_to_string(string_data: &[u8]) -> String {
    string_data.iter().map(|&s| s as char).collect()
}

#[derive(Debug)]
struct User {
    name: String,
    age: i32,
}

fn main() {
    // 元组
    let tup = (
        1,
        2,
        "hello",
        User {
            name: "y".to_owned(),
            age: 45,
        },
    );
    println!("tup {} {} {} {:?}", tup.0, tup.1, tup.2, tup.3);
    let (a, b, c, d) = tup;
    println!("a {} b {} c {} d {:#?}", a, b, c, d);

    // 数组
    let my_array = [1, 2, 3, 4];
    // let my_array: [i32;4] = [1,2,3,4];
    // let my_array: [i32;3] = [1, 2, 3];

    // 数组与切片
    let my_slice = &my_array[1..3];
    println!("my_array len {}", my_array.len());
    println!("my_slice len {}", my_slice.len());

    let u8_array = [121u8, 122u8, 122u8, 121u8];
    // &u8
    let u8_slice_ref = &u8_array[0..4]; //&[u8]
                                        // &u8_array u8_slice_ref 和 &u8_array是没有区别的
    println!("{:#?}", u8_to_string(&u8_array));
    println!("{:#?}", u8_to_string(u8_slice_ref));
}