详解Rust的数据类型和语法

文章目录

• • 基本数据类型
  • 复杂数据类型
  • 字符串
  • 基本语法

Rust是一种强调安全性和性能的系统编程语言。它的设计目标之一是防止内存安全错误同时提供丰富的功能和灵活的语法。下面介绍一下Rust语言的基本数据类型和语法。

基本数据类型

1.整数类型

有符号整数: i8, i16, i32, i64, i128, isize(指针大小的有符号整数)

无符号整数: u8, u16, u32, u64, u128, usize(指针大小的无符号整数)

let x: i32 = 123;      // 有符号32位整数
let y: u64 = 456;      // 无符号64位整数

2.浮点类型

Rust提供了两种基本的浮点型数据f32和f64，分别对应单精度和双精度浮点数。

let f: f32 = 1.23;     // 单精度浮点数
let d: f64 = 3.14159;  // 双精度浮点数

3.布尔类型

布尔类型bool有两个可能的值: true 和 false

let is_active: bool = true;
let is_greater: bool = 10 > 5;

4.字符类型

Rust的字符类型(char)代表一个Unicode标量值

let a: char = 'a';
let emoji: char = 'b';

5.数组类型

数组是多个相同类型值的集合，数组在Rust中的大小是固定的。

let arr: [i32; 5] = [1, 2, 3, 4, 5];
let first = arr[0];   // 访问第一个元素
let second = arr[1];  // 访问第二个元素

6.切片类型

切片类型允许开发者引用数组的一部分。切片是动态大小的，可以在运行时用来表示数组的一段连续区间。

let a = [1, 2, 3, 4, 5];
//包含左边界不包含右边界  
let slice = &a[1..3];  // 切片 包括索引1和2，不包括3

复杂数据类型

1.结构体(Structs)

结构体是一种创建自定义数据类型的方式，用于封装多个相关的值。

struct Person {
    name: String,
    age: u32,
}
let person = Person {
    name: String::from("Alice"),
    age: 30,
};

2.枚举(Enums)

枚举是一种定义可能的变量集合的类型，非常适合处理多种类型的情况。

Rust的枚举类型和C++的枚举类型功能差异还是比较大的，Rust的枚举能够携带数据和创建复杂的数据结构，而C++的枚举主要用于定义一组整型常数。Rust的枚举非常适合用于错误处理(通过Result和Option类型)、状态机、复杂数据结构的构建，而C++的枚举更多用于表示固定集合的简单值。

enum WebEvent {
    PageLoad,
    PageUnload,
    KeyPress(char),
    Click { x: i64, y: i64 },
}
let pressed = WebEvent::KeyPress('x');
let clicked = WebEvent::Click { x: 20, y: 80 };

3.元组(Tuples)

元组是一个可以包含多种类型的固定大小的有序列表，且长度固定。

let tuple: (i32, String, f64) = (500, String::from("hello"), 0.5);
let (x, y, z) = tuple;  // 解构
println!("The value of y is: {}", y);

4.集合(Collections)

Rust提供了几种标准库中的集合类型，如动态数组(Vec)、哈希映射(HashMap)、集合(HashSet)等，用于存储多个值。

//动态数组
let mut vec = Vec::new();
vec.push(1);
vec.push(2);
vec.push(3);

//哈希映射使用
use std::collections::HashMap;
let mut scores = HashMap::new();
scores.insert(String::from("Blue"), 10);
scores.insert(String::from("Yellow"), 50);

字符串

Rust中的字符串可以分为两大类:String和str

1.String类型

String是一个可增长、可变、拥有所有权的UTF-8字符序列。

//创建和修改String:
let mut s = String::new();

//从字面量创建String
let data = "initial contents";
let s = data.to_string();

//直接使用字面量
let s = String::from("initial contents");

//添加内容到String
s.push_str("more contents");
s.push('!');  // 添加单个字符  

2.str类型

str通常以借用形式出现为&str，是一个固定大小的字符串slice，指向一段UTF-8编码的内存。它是不可变的，通常用于处理程序中已存在的字符串。

let s: &str = "Hello, world!";
//拼接字符串
let mut s = String::from("Hello");
s += " world!";
//使用 push_str
s.push_str(" Nice to meet you!");
//获取字符串的长度
let len = s.len();
//遍历字符串中的字符  
for c in "hello".chars() {
    println!("{}", c);
}
// 输出每个字符
for b in "world".bytes() {
    println!("{}", b);
}
// 输出每个字节  
let hello = "Здравствуйте";
let s = &hello[0..4];  // "Зд"，每个字符2字节
// 格式化字符串  
let s = format!("{}-{}", "hello", "world");

基本语法

1.变量和可变性

默认情况下，Rust的变量是不可变的。使用mut关键字来声明可变变量。

let x = 5;       // 不可变变量
let mut y = 10;  // 可变变量
y = 20;

2.定义函数

使用fn关键字定义函数，函数参数需要声明类型，返回值类型用->指定。

Rust支持表达式(没有;结尾)和语句(有;结尾)。

fn add(x: i32, y: i32) -> i32 {
    x + y  // 这是一个表达式，不需要分号
}

3.控制流程

条件语句使用if，可选的else if和else，支持表达式

let number = 6;
if number % 4 == 0 {
    println!("Number is divisible by 4");
} else if number % 3 == 0 {
    println!("Number is divisible by 3");
} else {
    println!("Number is not divisible by 3 or 4");
}

loop、while和for循环

fn main() {
    let mut n = 0;
    //while循环  
    while n <= 5  {
        println!("{}!", n);

        n = n + 1;
    }

    //loop无条件循环  
    loop {
        if n > 5 {
            break
        }
        println!("{}", n);
        n+=1;
    }
    //for枚举循环  
    let array = [10, 20, 30, 40];
    for element in array.iter() {
        println!("Element: {}", element);
    }
}

4.所有权(Ownership)、借用(Borrowing)、引用(References)

Rust的所有权系统是其安全性和内存管理的基础。通常一个值有一个所有者，当所有者超出作用域时，值被丢弃。使用&符号来引用一个值，并用&mut来借用可变引用。所有权和借用体系是一个很复杂的系统，这里只做简单介绍，后续会详细介绍相关的语法。

fn main() {
    let s1 = String::from("hello");
    let len = calculate_length(&s1);
    println!("The length of '{}' is {}.", s1, len);
}

fn calculate_length(s: &String) -> usize {
    s.len()
}