rust切片

切片类型写为[T]。
切片是序列的一个片段。
它是动态大小类型，所以要使用切片类型，就必须使用它的指针类型。引用是最常用的指针类型。
[T; n]能隐式转换成[T]。

一、定义切片

（一）不可变切片
&[T]，共享切片，是不可变引用。
语法格式如下

let sliced_value: &[type] = &data[x..y]
1

data是个数组或向量

x..y表示 [x, y) 的数学含义。.. 两边可以没有运算数
..y等价于0..y
x.. 等价于位置x到结束
.. 等价于位置0到结束
1
2
3
4

（二）可变切片
&mut [T]，可变切片，是可变引用。
使用&mut关键字
语法格式

let slice_name: &mut[type] = &mut data[start..end]
1

data是个数组或向量
例子

fn main(){
     let mut data = [10,20,30,40,50];
     use_slice(&mut data[1..4]);
     // passes references of     20, 30 and 40
     println!("{:?}",data);
}
fn use_slice(slice:&mut [i32]) {
     println!("切片的长度为：{:?}",slice.len());
     println!("{:?}",slice);
     slice[0] = 1010; // replaces 20 with 1010
}
编译运行结果如下
切片的长度为：3
[20, 30, 40]
[10, 1010, 30, 40, 50]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

二、使用切片

（一）获取长度
例子

let mut arr: [u32; 5] = [1, 2, 3, 4, 5];
let a = &mut arr[2..4];
println!("{}", a.len());
1
2
3

（二）访问元素
[]
访问切片内容的时候，下标索引是从 0 开始的。

let mut arr: [u32; 5] = [1, 2, 3, 4, 5];
let a = &mut arr[2..4];
println!("{}", a[0]);
1
2
3

（三）遍历切片
1.使用索引

let mut arr: [u32; 5] = [1, 2, 3, 4, 5];
let a = &mut arr[2..4];
for i in 0..a.len() {
    a[i] = 0;
    print!("{} ", a[i]);
}
1
2
3
4
5
6

2.使用引用

let mut arr: [u32; 5] = [1, 2, 3, 4, 5];
let a = &mut arr[2..4];
for i in a {
    *i = 0;
    print!("{} ", i);
}
1
2
3
4
5
6

3.使用迭代器

let mut arr: [u32; 5] = [1, 2, 3, 4, 5];
let a = &mut arr[2..4];
for i in a.iter() {
    print!("{} ", i);
}

let mut arr: [u32; 5] = [1, 2, 3, 4, 5];
let a = &mut arr[2..4];
for i in a.iter_mut() {
    *i = 0;
    print!("{} ", i);
}
1
2
3
4
5
6
7
8
9
10
11
12

（四）切片作为函数参数
只能通过引用的方式传递给函数。

例子

fn main(){
     let data = [10,20,30,40,50];
     use_slice(&data[1..4]);
}
fn use_slice(slice:&[i32]) {
     println!("length of slice is {:?}",slice.len());
     println!("{:?}",slice);
}
编译运行结果如下
length of slice is 3
[20, 30, 40]
1
2
3
4
5
6
7
8
9
10
11

（五）切片转向量

let mut arr: [u32; 5] = [1, 2, 3, 4, 5];
let a = &mut arr[2..4];
let v = a.to_vec();
println!("{:?}", v);
1
2
3
4