【Rust学习】Rust数据类型，函数，条件语句，循环

本文专栏：Rust学习

一，数据类型

1，标量类型

1.1，整型

按照比特位长度和有无符号分为以下几种：

isize 和 usize 两种整数类型是用来衡量数据大小的，它们的位长度取决于所运行的目标平台，如果是 32 位架构的处理器将使用 32 位位长度整型。

在数学运算上Rust不支持++和--

1.2，整型溢出

例如：u8的范围是0-255，如果把一个u8类型的变量设为256。那么：

在调试模式下：Rust会检查整数 溢出，如果发生溢出，程序在运行时就会panic

在发布模式下（--release）：Rust不会检查真书溢出。如果溢出，Rust会执行环绕操作，如256变成0，257变成1.

1.3，浮点数型

Rust支持32位浮点数和64位浮点数。64位精度更高。

f64是默认的精度类型

fn main() { let a=2.0; //f64 let b:f32=3.0; //f32 }

1.4，布尔类型

布尔型用bool表示，值只能为true或false

1.5，字符型

字符型用char表示，Rust的char类型大小为4个字节。

是Unicode标量值，可以表示比ASCLL多得多的字符内容，如拼音，中日韩文，emoji表情等等。

fn main() { let _x='z'; let _y:char='&'; let _z='😽'; println!("_z is {}",_z); }

2，复合类型

2.1，Tuple(元组)

元组是用一对（ ）包括的一组数据，可以包含不同种类型的数据。

元组的长度是固定的。

访问Tuple元素：在Tuple变量后使用点标记法，后接元素的索引号。

fn main() { let tup:(i32,f64,u8)=(500,6.4,1); println!("{} {} {}",tup.0,tup.1,tup.2); }

获取Tuple的元素值：可以使用模式匹配来结构（destructure）一个Tuple获取元素值

fn main() { let tup:(i32,f64,u8)=(500,6.4,1); //模式匹配 let (x,y,z)=tup; println!("{} {} {}",x,y,z); }

2.2，数组

数组中每个元素的类型必须是相同的。数组的长度也是固定的。

数组用一对 [ ] 包括的同类型数据。

let a=[1,2,3,4];

数组的类型可以以这种方式进行表示：[ 类型;长度 ]

let a[i32;5]=[1,2,3,4,5];

如果数组的每个元素都相同，那么可以在中括号里指定初始值。

let a[3;5]； 它就相当于[3,3,3,3,3]

访问数组的元素，使用下标访问

fn main() { // a 是一个长度为 5 的整型数组 let a = [1, 2, 3, 4, 5]; // 数组访问 let first = a[0]; let second = a[1]; }

二，函数

2.1，函数的声明

声明函数使用 fn 关键字

其中 Rust 函数名称的命名风格是小写字母以下划线分割：

fn main() { println!("Hello, world!"); another_function(); } fn another_function() { println!("Hello, runoob!"); }

运行结果：

Hello, world! Hello, runoob!

Rust不会在乎在何处定义了函数，只要定义了就可以使用，而C/C++的函数必须定义在调用者之前。

2.3，函数的参数

函数如果需要定义参数，必须声明类型

fn main() { another_function(5, 6); } fn another_function(x: i32, y: i32) { println!("x 的值为 : {}", x); println!("y 的值为 : {}", y); }

2.4，函数体的语句和表达式

Rust函数体由一系列的语句组成，语句是执行某些操作并且没有返回值的步骤，如：

let a = 6;

语句没有返回值，所以不可以let将一个语句赋给一个变量。

这个步骤没有返回值，所以以下语句不正确

let a = (let b = 2);

表达式是有返回值的。以下是表达式：

a = 7 b + 2 c * (a + b)

Rust 中可以在一个用 { } 包括的块里编写一个较为复杂的表达式：

fn main() { let x=5; let y={ let x=3; x+1 //这个表达式 就会作为返回值返回 }; println!("x is {}",x); println!("y is {}",y); }

在这个块中：

{ let x = 3; x + 1 };

注意：x+1之后没有分号，如果有分号，将会变成一条语句，没有返回值

在整个块中，最后一个步骤是表达式，此表达式的结果值是整个表达式块结果值，这种表达式叫做函数体表达式。在块中，也可以使用函数语句。

如果在块的最后一个步骤加上分号，那么将成为一条语句，没有 返回值。

此时该表达式 块的返回值就是一个空元组（Tuple），也就是 ( )。无法打印出来

{ let x = 3; x + 1; //（） };

2.5，函数的返回值

在参数声明之后用 -> 来声明函数返回值的类型。

在函数体中，随时都可以以 return 关键字结束函数运行并返回一个类型合适的值。

大多数函数都是使用最后一个表达式作为默认的返回值的。

fn add(a: i32, b: i32) -> i32 { return a + b; }

注意：函数体表达式不同于函数体，它不能使用return关键字。

在Rust中，函数可以嵌套定义。

fn main() { fn five() -> i32 { 5 } println!("five() 的值为: {}", five()); }

三，条件语句

if 后的变量必须是bool类型的，Rust不会像C语言一样将它转化位bool类型，会直接报错。

fn main() { let number=3; if number<5 { println!("condition was true"); } else { println!("condition was false"); } }

条件表达式 number < 5 不需要用小括号包括。

但是 Rust 中的 if 不存在单语句不用加 {} 的规则，不允许使用一个语句代替一个块。

fn main() { let a = 12; let b; if a > 0 { b = 1; } else if a < 0 { b = -1; } else { b = 0; } println!("b is {}", b); }

因为if是一个表达式，所以可以将他放在let语句等号的右边。

fn main() { let condition=true; let number=if condition {5} else {6}; println!("number is {}",number); }

其中if 和else块中的返回值类型必须相同。如果不同，那么在编译的时候就无法确定number的类型。

四，循环

1，while循环

fn main() { let mut number = 1; while number != 4 { println!("{}", number); number += 1; } println!("EXIT"); }

2，for循环

fn main() { let a = [10, 20, 30, 40, 50]; for i in a.iter() { println!("值为 : {}", i); } }

Range由标准库提供，指定一个开始数字和一个结束数字，Range可以生成他们之间的数字，不包含结束数字。rev方法可以反转Range。示例：

fn main() { for number in 1..4 { println!("number is {}",number); } }

fn main() { for number in (1..4).rev() { println!("number is {}",number); } }

3，loop循环

Rust 语言有原生的无限循环结构 —— loop

可以在loop循环里使用break关键字，告诉程序何时停止循环。

fn main() { let mut counter=0; let result=loop{ counter+=1; if counter==10 { break counter*2; //返回counter*2 } }; println!("result is {}",result); }