前言

你好，我是醉墨居士，前面我们学习了如何使用rust在控制台进行输出，接下来我将带给大家一些关于计算机的基础知识，这能够帮助我们更好的理解rust

整数类型

有符号整数：i8，i16，i32，i64，i128

let num_int8: i8 = 0; // 8位整数
let num_int16: i16 = 0; // 16位整数
let num_int32: i32 = 0; // 32位整数
let num_int64: i64 = 0; // 64位整数
let num_int128: i128 = 0; // 128位整数
println!("{} {} {} {} {}", num_int8,  num_int16, num_int32, num_int64, num_int128);

无符号整数：u8，u16，u32，u64，u128

let num_uint8: u8 = 0; // 8位整数
let num_uint16: u16 = 0; // 16位整数
let num_uint32: u32 = 0; // 32位整数
let num_uint64: u64 = 0; // 64位整数
let num_uint128: u128 = 0; // 128位整数
println!("{} {} {} {} {}", num_uint8,  num_uint16, num_uint32, num_uint64, num_uint128);

浮点数类型

单精度浮点数：f32

let num_float32: f32 = 0.0; // 32位浮点数
println!("{}", num_float32);

双精度浮点数：f64

let num_float64: f64 = 0.0; // 64位浮点数
println!("{}", num_float64);

布尔类型

表示true、false的bool类型

let code: bool = true;
println!("{}", code);

字符类型

表示Unicode字符的char类型

let c: char = '醉';
println!("{}", c);

字符串字面量

let s: &str = "醉墨居士";
println!("{}", s);

元组类型

组合不同类型值的复合类型，其容器本身不可变!

let nums: (i32, char, &str) = (1, '2', "3");
println!("{} {} {}", nums.0, nums.1, nums.2);

数组类型

固定长度的同类型元素的集合

let nums: [i32; 3] = [1,2,3];
println!("{} {} {}", nums[0], nums[1], nums[2]);

切片类型

指向数组或者其他数据结构一部分元素的引用

let nums: [i32; 5] = [1,2,3,4,5];
let slice: &[i32] = &nums[1..4];
println!("{:?}", slice);

枚举类型

包含一些枚举的“变体”（variants）。每个变体可以携带不同的数据类型或不携带数据

#[derive(Debug)]
enum Color {Red,Green,Blue,
}let color: Color = Color::Red;
println!("{:?}", color);

结构体类型

组合多个不同类型的数据组合到一个单独的结构

#[derive(Debug)]
struct Color {red: u8,green: u8,blue: u8,
}let color: Color = Color { red: 128, green: 0, blue: 255 };
println!("{:?}", color);

指针类型

Rust语言鼓励使用引用而不是原始指针，因为引用在编译时具有更强的类型检查，可以避免许多内存安全问题。只有在特定情况下，比如与C语言交互或进行unsafe操作时，才需要使用原始指针

1. 引用：表示对某个值的引用，使用&符号来创建。引用在Rust中有不可变和可变两种类型

let mut i: i32 = 0;
let i_ref = &i; // 不可变引用
println!("{}", i_ref);let mut i_ref = &mut i; // 可变引用
println!("{}", i_ref);

2. 原始指针：
   *const T：不可变的原始指针，类似于C语言中的const T *

let i: i32 = 0;// 创建一个常量指针
let ptr_const: *const i32 = &i;
unsafe {// 常量指针指向的地址与解引用println!("{:?} {}", ptr_const, *ptr_const);
}

*mut T：可变的原始指针，类似于C语言中的T *

let mut i: i32 = 0;// 创建一个可变指针
let ptr_mut: *mut i32 = &mut i;
unsafe {// 可变指针之指向的地址与解引用println!("{:?} {}", ptr_mut, *ptr_mut);
}

最后

我们已经介绍了rust中基本的数据类型，希望你有所能收获