系列文章目录
【跟小嘉学 Rust 编程】一、Rust 编程基础
【跟小嘉学 Rust 编程】二、Rust 包管理工具使用
【跟小嘉学 Rust 编程】三、Rust 的基本程序概念
前言
本章节涵盖几乎所有编程语言会出现的概念以及他们在 Rust之中的工作原理,这不是 Rust 独有的,但我们将在 Rust 上下文中讨论他们,并且解释这些概念。详细来讲就是变量、基本类型、函数、注释和控制流。
主要教材参考 《The Rust Programming Language》
一、变量以及可变性
1.1、变量声明语法
let [mut] variableName[:type] [= initialValue]
- 变量必须先声明在使用
- rust 没有默认构造函数,变量没有默认值;
- variableName 以字母(unicode)、下划线、数字组成,但是必须以字母(unicode)、下划线开头;
- 未声明类型的为自动类型推导,但不意味着动态类型。
1.2、不可变变量
默认情况下,变量是不可变的,这是 Rust 提供的用于安全性和简单并发性方式编写代码。
例子:不可变变量
fn main() {
let x = 5;
println!("The value of x is: {x}");
x = 6;
println!("The value of x is: {x}");
}
错误提示
raojiamin@192 hello % cargo build
Compiling hello v0.1.0 (/Users/raojiamin/Desktop/code/rust_code/hello)
error[E0384]: cannot assign twice to immutable variable `x`
--> src/main.rs:4:5
|
2 | let x = 5;
| -
| |
| first assignment to `x`
| help: consider making this binding mutable: `mut x`
3 | println!("The value of x is: {x}");
4 | x = 6;
| ^^^^^ cannot assign twice to immutable variable
For more information about this error, try `rustc --explain E0384`.
error: could not compile `hello` (bin "hello") due to previous error
初始化本身可以依赖变量,可能多次调用它所在函数可能得到不同的值;
1.3、未使用变量警告
如果你声明了变量但是并未使用,编译器则会给你一个变量未使用的警告。
warning: unused variable: `x`
--> src/main.rs:2:9
|
2 | let x = 5;
| ^ help: if this is intentional, prefix it with an underscore: `_x`
|
= note: `#[warn(unused_variables)]` on by default
warning: `hello` (bin "hello") generated 1 warning (run `cargo fix --bin "hello"` to apply 1 suggestion)
Finished dev [unoptimized + debuginfo] target(s) in 0.89s
1.4、使用 let mut 可变变量
fn main() {
let mut y = 100;
// help: maybe it is overwritten before being read?rustc(unused_assignments)
// 如果在第二次赋值前没有读取该变量会有上述警告
println!("the y value is {}", y);
y = 100;
println!("the y value is {}", y);
}
1.5、使用 const 声明常量
初始化过程完全静态(编译器时期已知其值),且不会改变。
fn main() {
const X:i32 = 100;
// warning: constant is never used: `x` 警告:常量必须被使用
// warning: constant `x` should have an upper case name 常量必须大写
// error: missing type for `const` item 错误:常量必须声明类型
println!("the X value is {}", X);
}
const 常量一定不能 使用 mut 修饰。
1.6、Shadowing
该特性可以反复声明不可变对象,她可以重新更改不可变变量的数据类型,该语法特性一般用于中间变量。
fn main() {
let x = 5;
let x = x + 1;
let x = x * 2;
println!("The value of x is: {}", x);
}
该特性不允许使用在可变对象上。
fn main() {
let mut spaces = " ";
spaces = spaces.len();
}
错误提示
cargo build
Compiling hello v0.1.0 (/Users/raojiamin/Desktop/code/rust_code/hello)
error[E0308]: mismatched types
--> src/main.rs:3:14
|
2 | let mut spaces = " ";
| ----- expected due to this value
3 | spaces = spaces.len();
| ^^^^^^^^^^^^ expected `&str`, found `usize`
|
help: try removing the method call
|
3 - spaces = spaces.len();
3 + spaces = spaces;
|
For more information about this error, try `rustc --explain E0308`.
error: could not compile `hello` (bin "hello") due to previous error
1.7、暂时不使用的变量
fn main() {
let _ = "hello";
let _num = 100; // 表示可暂时不使用该变量
println!("{}", _); // 编译错误!“_” 的含义是忽略该变量绑定,之后不会再用了
}
以下划线开头的变量名,如 ”_num“, 表示可以暂时不使用该变量;
1.8、全局常量和全局静态变量
在Rust 之中没有全局变量的概念,但是可以使用全局静态变量和全局常量。
1.8.1、全局常量
- 全局常量必须在声明的时候初始化;
- 全局常量名必须大写
- 全局常量必须在声明的时候显示声明类型;
1.8.2、全局常量
- 静态变量必须在声明时初始化;
- 静态变量必须编译时可确定的常量, 变量名必须大写;
- mut 修饰的静态变量,使用的时候必须 unsafe 函数或者 unsafe 代码块;
- 静态变量在声明时候必须指定静态的变量的数据类型;
二、数据类型
2.1、标量类型(Scalar Types)
标量类型表示单个值。Rust 中有四种主要的标量类型:整型、浮点型、布尔类型、字符。
2.1.1、整型(Integer Types)
2.1.1.1、几种整型类型
整型数据默认是 i32 类型, isize 或 usize 在 32 位机器上就是 4 个字节,在 64 位机器上就是 8 个字节。
Length | Signed | Unsigned| |
---|---|---|
8-bit | i8 | u8 |
16-bit | i16 | u16 |
32-bit | i32 | u32 |
64-bit | i64 | u64 |
128-bit | i128 | u128 |
arch | isize | usize |
每一个变量都可以是有符号或无符号,并且具有明确的大小,有符号数使用二进制补码来表示存储。(早期8086 cpu只支持加法指令)
- 原码:最高位为符号位,0代表正数,1代表负数,其余各位为数值本身的绝对值
- 反码:
- 正数:反码与原码相同,这是规定;
- 负数:符号位为1不变,其余位对原码取反;
- 补码:
- 正数:补码与原码相同
- 负数:符号位为1不变,其余位对原码取反加1;
isize 和 usize的主要场景是对某种集合进行索引操作。
2.1.1.2、整型字面量(Integer Literals)
Number literals | Example | |
---|---|
Decimal | 98_222 |
Hex | 0xff |
Octal | 0o77 |
Binary | 0b1111_000 |
Byte(u8 only) | b’a’ |
除了byte类型外,所有数值字面量都允许使用类型后缀,例如:67u8;
2.1.1.3、整数溢出
u8的范围是0-255,如果你把一个 u8的值设置为 256。
- 调试模式(Debug)下,rust 会检查整数溢出,如果发生溢出,程序会在运行时就会 panic。
- 发布模式(Release)下,rust 不会检查整数溢出,若果发生溢出,rust 会执行环绕操作,不会抛出 panic;
如果要在 release 模式下打开整数溢出检查后,只需要在 Cargo.toml 中配置
[profile.release]
overflow-checks = true
2.1.2、浮点型(Floating-Point Types)
浮点数有两种类型:f32(单精度)、f64(双精度)。Rust的浮点类型使用了 IEEE-754 标准来表述。 f64 是默认类型,因为在现代 CPU 上 f64 和 f32 的速度差不多,而且精度更高。
2.1.3、布尔类型(Boolean Type)
布尔类型只有两个值:true、false。布尔类型的大小为1 字节,在 rust 中 布尔类型使用 bool 关键字。
2.1.4、字符(Character Type)
字符类型是一个比较特别的,在 Java 和 CPP 之中 都只占用 1个字节,但是 Rust 为了支持描述任何一个 unicode 字符, char 类型需要 4个字节来描述,这样会带来空间资源的浪费,因为 ASCII 字符其实只需要 1 个字节的空间。如果只需要单字节即可,Rust 给出的解决方案是用 ‘b’ 来声明单字节,将字符以u8类型的形式存储。
let x: u8 = b'A'; // 占 1 个字节
let y: char = 'A'; // 占 4 个字节
2.1.5、数字操作
Rust 支持所有数字类型所需要的基本数学操作:+、-、*、/、% 。 整数触发会向零截断到最接近的整数。
fn main() {
// addition
let sum = 5 + 10;
// subtraction
let difference = 95.5 - 4.3;
// multiplication
let product = 4 * 30;
// division
let quotient = 56.7 / 32.2;
let truncated = -5 / 3; // Results in -1
// remainder
let remainder = 43 % 5;
}
2.2、复合类型(Compound Types)
复合类型可以将多个值分组到一个类型中,Rust 中有两种基本复合类型:元组和数组。
2.2.1、元组(Tuple Type)
元组是一个具有多种数据类型的多个值组合成一个复合类型,元组有固有的长度。一旦声明它们的长度就不会增长或缩小。
2.2.1.1、元组定义
我们通常在括号内写一个逗号分隔的值列表来创建元组。
fn main() {
let tup:(i32, f64, u8) = (500, 6.4, 1);
// 定义空元组
let tup01:() = ();
// 单个元素元组
let tup02 = (1,);
println!("{:?}", tup01);
println!("{:?}", tup02);
println!("{:?}", tup);
}
需要注意:
- 如果你使用显示数据类型声明单个元素的元组,编译器会给出警告;
- 如果你要声明单个元素,必须使用自动类型推断,并且初始化的时候必须带有逗号,否则会被编译器认为是单个元素变量;
2.2.1.2、访问元组的方式
2.2.1.2.1、模式解构
fn main() {
let tup:(i32, f64, u8) = (500, 6.4, 1);
let (x, y, z) = tup;
println!("{:?}", tup);
println!(" the value of x is :{}", x);
println!(" the value of y is :{}", y);
println!(" the value of z is :{}", z);
}
2.2.1.2.2、数字索引(使用.
来访问元组)
模式解构可以让我们一次性把元组全部获取出来,如果我们想要访问某个元组, 可以使用 . 操作符来访问;和其他语言一样 数组、字符串、元组的索引从0开始。
fn main() {
let x: (i32, f64, u8) = (500, 6.4, 1);
let five_hundred = x.0;
let six_point_four = x.1;
// 如果索引不在范围内,会报如下错误 error[E0609]: no field `3` on type `(i32, f64, u8)`
println!("five_hundred is {}", five_hundred);
println!("six_point_four is {}", six_point_four);
}
2.2.2、数组(Array Type)
数组的每个元素都必须具有相同的类型,数组具有固定的长度,依次线性排列。
2.2.2.1、数组的定义
数组的定义格式如下:let 变量名[类型; 数组长度] = [初始化列表];
fn main() {
let array:[i32; 3] = [1,3,5];
let months = ["January", "February", "March", "April", "May", "June", "July",
"August", "September", "October", "November", "December"];
// 如果一个数组有多个重复的元素的时候
let a = [3;5];
println!("array: {:?}", array);
println!("months: {:?}", months);
}
2.2.2.2、数组的访问
使用索引访问数组的元素,索引从0开始,到数组长度-1;如果超出数组索引访问将会运行时报错。
fn main() {
let a = [9, 8, 7, 6, 5];
let first = a[0]; // 获取a数组第一个元素
let second = a[1]; // 获取第二个元素
println!("first: {:?}", first);
println!("second: {:?}", second);
}
索引越界的时候,程序将会执行错误
error: this operation will panic at runtime
--> src/main.rs:5:18
|
5 | let second = a[6]; // 获取第二个元素
| ^^^^ index out of bounds: the length is 5 but the index is 6
|
= note: `#[deny(unconditional_panic)]` on by default
error: could not compile `hello` (bin "hello") due to previous error
三、函数
函数在Rust代码只能够很常见,我们已经见到了最重要的函数 main 函数,他是许多程序的入口函数,我们还看到了 fn 关键字。
3.1、函数定义
在 rust 里面函数使用 fn 关键字声明。rust中函数名采用所有字母都是小写的,并且使用下划线分隔单词。函数使用大括号包括起来。
// 无参函数
fn another_function() {
println!("Another function.");
}
3.2、函数参数(parameters)
// 函数参数,函数的参数必须声明参数的类型
fn another_function(x: i32) {
println!("Another function.");
}
- 定义函数的时候声明的参数叫做形式参数;
- 调用函数的时候传入的参数叫做实际参数;
3.3、返回值(Return Values)
// 函数返回值
fn five() -> i32 {
println!("Another function.");
return 5; //或者直接写 5
}
在 rust 里面,函数可以在函数里面定义,也可以在函数外面定义。
函数里包含了语句和表达式。在rust语言里面。函数定义也是语句,所以函数可以在函数内部定义。
需要注意的是我们在省略 return 关键字的时候,不能带有分号,否则会报错
error[E0308]: mismatched types
--> src/main.rs:7:24
|
7 | fn plus_one(x: i32) -> i32 {
| -------- ^^^ expected `i32`, found `()`
| |
| implicitly returns `()` as its body has no tail or `return` expression
8 | x + 1;
| - help: remove this semicolon to return this value
3.4、语句和表达式(Statements and Expressions)
函数体是由一些语句组成,可选地以表达式结尾。
3.4.1、语句
执行某些操作但不返回值的指令
3.4.1.1、赋值语句
let y = 6;
let 语句不能作为赋值语句的右值。
3.4.1.2、代码块
fn main() {
let y = {
let x = 3;
x + 1
};
println!("The value of y is: {y}");
}
3.4.2、表达式
表达式求值为结果值。
四、注释(Comments)
所有程序员都努力使它们的代码易于理解,但是有时候额外的解释是必要的,编译器会忽略这些注释。
五、控制流(Control Flow)
5.1、if 表达式
if 表达式 允许根据条件对代码进行分支选择,如果条件满足,则运行,否则不运行。
if 后面必须得更 bool 类型变量或表达式,否则将会报错
error[E0308]: mismatched types
--> src/main.rs:4:8
|
4 | if number {
| ^^^^^^ expected `bool`, found integer
5.1.1、if else 表达式
1、双分支结构
fn main() {
let number = 3;
if number < 5 {
println!("condition was true");
} else {
println!("condition was false");
}
}
2、多分枝结构
fn main() {
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 if number % 2 == 0 {
println!("number is divisible by 2");
} else {
println!("number is not divisible by 4, 3, or 2");
}
}
5.1.2、在let语句中使用 if
在 let 语句右边可以使用 if 表达式,但是要求两个分支的值要是相同的类型,否则将会报错
fn main() {
let condition = true;
let number = if condition { 5 } else { 6 };
println!("The value of number is: {number}");
}
5.2、循环(loops)
5.2.1、loop 循环
5.2.1.1、loop 死循环
fn main() {
loop {
println!("again!");
}
}
5.2.1.2、loop 循环返回值
fn main() {
let mut counter = 0;
let result = loop {
counter += 1;
if counter == 10 {
break counter * 2;
}
};
println!("The result is {result}");
}
5.2.1.2、loop 标签结合break 来跳出指定循环
fn main() {
let mut count = 0;
'counting_up: loop {
println!("count = {count}");
let mut remaining = 10;
loop {
println!("remaining = {remaining}");
if remaining == 9 {
break;
}
if count == 2 {
break 'counting_up;
}
remaining -= 1;
}
count += 1;
}
println!("End count = {count}");
}
5.2.2、while 循环
5.2.2.1、while 循环
fn main() {
let mut number = 3;
while number != 0 {
println!("{number}!");
number -= 1;
}
println!("LIFTOFF!!!");
}
5.2.2.2、使用 while 循环遍历数组
fn main() {
let a = [10, 20, 30, 40, 50];
let mut index = 0;
while index < 5 {
println!("the value is: {}", a[index]);
index += 1;
}
}
5.2.3、for 循环
5.2.3.1、遍历序列
fn main() {
for i in 1..11 {
println!("{}", i);
}
}
其中 1…11 是 Range 对象的定义形式,表示的是1-10 的序列;文章来源:https://www.toymoban.com/news/detail-495918.html
fn main() {
for number in (1..4).rev() {
println!("{number}!");
}
println!("LIFTOFF!!!");
}
5.2.3.2、迭代器循环
fn main(){
let fruits=["mango","apple","banana","litchi","watermelon"];
for fruit in fruits.iter()
{
print!("{:?} ",fruit);
}
}
5.2.3.3、数组遍历
fn main() {
let a = [10, 20, 30, 40, 50];
for element in a {
println!("the value is: {element}");
}
}
总结
以上就是今天要讲的内容文章来源地址https://www.toymoban.com/news/detail-495918.html
- 本文介绍了 Rust 基本程序概念,主要包含 Rust 变量和常量的定义使用、Rust 数据类型、Rust 流程控制;
到了这里,关于【跟小嘉学 Rust 编程】三、Rust 的基本程序概念的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!