Rust 基本数据类型、元组、数组、切片

LiuJP
90 阅读5分钟

基本数据类型

  • Integer types 默认 i32 i8 i16 i32 i64 i128

  • Unsigned Integer Types u8 u16 u32 u64 u128

  • Platform-Specific Integer Types (平台决定) usize isize

  • Float Types f32 f64 尽量使用f64 ，除非你清楚边界需要的空间

  • Boolean Values true false

  • Character Types Rust 支持 Unicode 字符； 表示 char 类型使用单引号；


fn main() {
    println!("Hello, world!");
    // rust_ch1();
    _rust_ch2();
}

fn _rust_ch2(){
    let a1 = -125;
    let a2 = 0xFF;
    let a3 = 0o13;
    let a4 = 0b10;
    println!("{a1},{a2},{a3},{a4}");

    //Max Min
  
    println!("u32 max {}",u32::MAX);
    println!("u32 min {}",u32::MIN);
    println!("i32 max {}",i32::MAX);
    println!("i32 min {}",i32::MIN);
    println!("uszie max {}",usize::MAX);
    println!("iszie max {}",isize::MAX);
    println!("iszie is {} bytes",std::mem::size_of<isize>());
    println!("uszie is {} bytes",std::mem::size_of::<usize>());
    println!("u64 is {} bytes",std::mem::size_of::<u64>());
    println!("i64 is {} bytes",std::mem::size_of::<i64>());

}


fn _rust_ch1(){
    let x  = 5;
    println!("1 x {x}");
    let x = "hello";
    println!("2 x {x}");
    let mut x = false;
    println!("3 x {x}");
    x = true;
    println!("4 x {x}");
}

元组、数组、切片

相同点：

  • 元组和数组都是 Compound Types， 而 Vec 和 Map 都是 Collection Types
  • 元组和数组的长度都是固定的

Tuples 不同类型的数据组成 Arrays 相同类型的数据组成

fn _ch3() {
    // tuple
    let tup = (0, false, "1", 3.4);
    // 使用let解构
    let (a, b, c, d) = tup;
    println!("a: {}, b: {}, c: {} d: {}", a, b, c, d);
    // 模板匹配
    match tup {
        (a, b, c,d) => {
            println!("Name: {}, Age: {}, Height: {} {}", a, b, c,d);
            // 输出：Name: true, Age: 30, Height: 5.8
        }
    };
    println!("tup2:{}", tup.2);

    //array
    let arr = [1, 2, 3, 4, 5, 6, 7];
    println!("{}", arr[0]);
    // 遍历
    for ele in arr {
        println!("{ele}");
    }

    // iter遍历
    for (index, &value) in arr.iter().enumerate() {
        println!("Element {}: {}", index + 1, value);
    }

    //切片 : 创建一个包含 my_array 中索引 1 到 3 的元素的切片
    let slice: &[i32] = &arr[1..4];

    println!("slice: {:?}", slice);
    // 输出: my_slice: [2, 3, 4]

    for item in slice.iter() {
        println!("Item: {}", item);
    }
}

数组

数组长度固定，元素类型相同 array

元组

元组是固定长度的异构集合 tuple

切片

切片可以从数组、向量或其他支持切片操作的数据结构中创建。你可以使用 & 符号将数据的引用转换为切片，或者使用 &data[start..end] 的语法来创建一个新的切片。

字符串切片

在 Rust 中，字符串切片是一种特殊类型的切片，通常用 &str 表示。其中 & 表示引用，而 str 表示字符串切片的类型。

字符串切片是对字符串数据的引用，允许你引用字符串中的一部分字符序列，而无需拥有整个字符串的所有权。

字符串切片是 Rust 中处理文本数据的重要工具。

字符串切片可以从字符串字面值、String 类型的字符串或其他字符串切片中创建。你可以使用 & 符号将字符串引用转换为字符串切片，或者通过切片语法 &string[start..end] 来创建一个新的字符串切片。

fn main() {
    let string_literal: &str = "Hello, lanyulei!"; // 从字符串字面值创建字符串切片
    println!("{}", string_literal);
    // 输出：Hello, lanyulei!

    let string_data: String = String::from("Rust is great!");
    let slice: &str = &string_data; // 从 String 创建字符串切片
    println!("{}", slice);
    // 输出：Rust is great!

    let sub_slice: &str = &slice[0..4]; // 通过切片语法 &string[start..end] 来创建一个新的字符串切片，创建包含 "Rust" 的字符串切片
    println!("{}", sub_slice);
    // 输出：Rust
}

字符串切片是不可变的，这意味着你不能修改字符串切片中的字符。

字符串的不可变性在 Rust 中是强制执行的，哪怕是使用了 mut 关键字仍然是不可变的，这有助于防止一些常见的编程错误。

fn main() {
    let mut string_data: &str = "Hello lanyulei!";
    // 下面的代码尝试修改字符串切片中的字符，会导致编译错误
    // string_data[0] = 'h'; // 无法编译，因为字符串切片是不可变的
}

你可以使用 .len() 方法获取字符串切片的长度，以及使用迭代器进行字符遍历。

fn main() {
    let text: &str = "Rust is great!";
    let length: usize = text.len(); // 获取字符串切片的长度
    println!("length: {}", length);
    // 输出: length: 14

    // 使用 `chars` 方法迭代字符串切片中的字符
    for c in text.chars() {
        println!("Character: {}", c);
    }
}

字符串切片与模式匹配结合使用非常有用，允许你根据字符串内容执行不同的操作。

fn main() {
    let text: &str = "Rust";
    match text {
        "Rust" => println!("Found Rust!"),
        "Java" => println!("Found Java!"),
        _ => println!("Not found"),
    }
}

字符串切片在 Rust 中广泛用于文本处理、字符串搜索、解析和分割等操作。由于其不可变性和引用语义，它们是编写安全且高性能的代码的关键组成部分。在处理字符串时，使用字符串切片通常比拥有整个字符串的所有权更高效，因为不需要复制字符串的内容。因此，字符串切片是 Rust 中处理字符串数据的常见选择。

切片的模式匹配

切片可以与模式匹配结合使用，允许你根据切片的内容执行不同的操作。

fn main() {
    let data: [i32; 5] = [1, 2, 3, 4, 5];
    let slice: &[i32] = &data[1..4];
    match slice {
        [2, 3, 4] => println!("Matched [2, 3, 4]"),
        _ => println!("Not matched"),
    }
}

总而言之，切片是 Rust 中用于引用集合部分数据的强大工具，它们允许你在不拥有所有权的情况下有效地操作和处理数据。切片在许多 Rust 代码中都有广泛的应用，特别是在处理字符串和集合数据时。

avatar
文章
阅读
粉丝