概述
Rust是一门现代的系统编程语言，由Mozilla开发，专注于安全性、速度和并发性。
Rust的特点
- 内存安全
无需垃圾回收器，通过所有权系统在编译时保证内存安全。 - 零成本抽象
高级抽象不会带来运行时开销 - 并发安全
编译时防止数据竞争 - 性能优异
性能可与C/C++媲美 - 类型系统强大
静态类型检查，减少运行时错误
Rust的应用场景
- 系统编程（操作系统、嵌入式系统）
- Web后端开发
- 区块链开发
- 游戏引擎
- 网络服务
- 命令行工具
rust
fn main(){
println!("Hello, Rust!");
// Rust 程序的基本结构
// 1. fn 关键字定义函数
// 2. main函数是程序的入口
// 3. println! 是宏，用于打印输出
// 4. 分号表示语句结束
// 编译和运行
// 使用 cargo new hello_rust 创建新项目
// 使用 cargo run 编译并运行程序
// 使用 cargo build 只编译不运行
}Rust变量与可变性
在Rust中，变量默认是不可变的，当你使用let关键字声明变量时，一旦绑定了值，就不能再改变它。如果需要改变变量的值，必须使用mut关键字
rust
fn main(){
// 1.不可变量
let x=5;
println!("x 的值是:{}",x);
// 2.可变变量
let mut y=10;
println!("y 的初始值是:{}",y);
y=20;
println!("y 的修改后的值: {}",y);
const MAX_POINTS:u32=100_000;
println!("MAX_POINTS:{}",MAX_POINTS);
}数据类型
- 整数类型: i8,i16,i32,i64,i128,isize和对应的无符号类型 u8,u16,u32,u64,u128,usize
- 浮点类型: f32,f64
- 布尔类型: bool
- 字符类型: char (4字节 Unicode)
- 复合类型: 元组 (tuple)和数组(array)
rust
fn main(){
let tup:(i32,f64,bool)=(500,6.4,true);
let (a,b,c)=tup;//解构
println!("a={}, b={}, c={}",a,b,c);
//数组(固定长度)
let arr: [i32;5]=[1,2,3,4,5];
println!("第一个元素: {}",arr[0]);
}函数
函数是Rust代码的基本构建块，使用fn关键字定义函数
函数可以：
-
接收参数
-
返回值
-
有明确的类型标注
rust
fn main(){
let result = add (5,3);
println!("5 + 3 = {}", result);
let product = multiply(4,7);
println!("4 * 7 = {}", product);
greet("Rust");
let num = get_number();
println!("获取的数字: {}", num);
}
fn add (x:i32,y:i32)->i32{
x+y //没有分号，这是表达式，会返回值
}
fn multiply (x:i32,y:i32)->i32{
return x*y; //使用return也可以
}
fn greet(name:&str){
println!("Hello, {}!", name);
}
fn get_number()->i32{
42 //最后一个表达式作为返回值
}注释
注释是代码中不会被执行的文本，用于解释代码的功能
Rust支持两种注释：
- 行注释：使用//，从//开始到行尾都是注释
- 块注释：使用/ /.可以跨越多行
文档注释使用///，可以生成文档
rust
fn main() {
let x=5;
/* 这是块注释
可以跨越多行
非常方便 */
let y=10;
/// 这是文档注释
/// 用于生成API文档
fn documented_function(){
// 函数实现
}
}控制流 if/else
if表达式允许根据条件执行不同的代码分支
在Rust中，if是一个表达式，这意味着它可以返回值。条件必须是bool类型，不能像其他语言那样使用数字或指针。
rust
fn main() {
let number=6;
if number<5 {
println!("数字小于5");
}else{
println!("数字大于等于5");
}
if number%4==0{
println!("数字能被4整除");
}else if number%3==0{
println!("数字能被3整除");
}else if number%2==0{
println!("数字能被2整除");
}
else {
println!("数字不能被2、3、4整除");
}
let condition =true;
let result = if condition{
5 //没有分号
}else {
6
};
println!("{}", result);
// 在 let语句中使用if
let number = if true { 42 }else{ 0 };
println!("{}", number);
}循环
- loop: 无限循环，直到遇到break
- while: 条件循环
- for: 遍历集合或范围
rust
fn main() {
let mut counter = 0;
let result = loop{
counter += 1;
if counter == 10 {
break counter * 2; // break 可以返回值
}
};
println!("{}", result);
// while 条件循环
let mut number=3;
while number != 0 {
println!("{}", number);
number-=1;
}
println!("发射！");
// for遍历集合
let arr = [10,20,30,40,50];
for element in arr.iter() {
println!("值是{}", element);
}
// for 遍历范围
for number in 1..4{
println!("{}", number);
}
//包含4
for number in 1..=4{
println!("{}", number);
}
}所有权基础
所有权是Rust最独特的特性，每个值都有一个所有者，当所有者离开作用域时，值会被丢弃。
作用域是变量有效的代码范围，当变量进入作用域时有效，离开作用域时无效。
rust
fn main() {
// s在这里无效，尚未声明
{
let s = "hello"; // s从这里开始有效
//使用s
println!("{}", s);
}
// 字符串字面量(&str)存储在栈上
let s1 = "hello";
let s2=s1; // s1、s2都有效因为实现了copy
// String类型存储在堆上
let s3 = String::from("hello");
let s4=s3; // s3的所有权移动到s4,s3失效
//println!("{}",s3) 错误，s3已失效
println!("{}", s4);
}作用域
rust
fn main() {
let outer = "outer";
println!("outer: {}", outer);
{
// 内层作用域
let inner = "inner";
println!("inner: {}", inner);
println!("outer: {}", outer); // 可以访问外层变量
} // inner在这里失效
println!("outer: {}", outer);
// 变量遮蔽
let x=5;
let x=x+1; // 遮蔽了之前的x
{
let x=x*2; // 遮蔽了外层的x
println!("x: {}", x); // 12
}
println!("x: {}", x); // 6
}