Rust学习笔记_16——Vector

Rust学习笔记_13------枚举
 Rust学习笔记_14------结构体
 Rust学习笔记_15------Union

Vector

文章目录

- Vector
- - [1. 创建Vector](#1. 创建Vector)
  - [2. 访问](#2. 访问)
  - [3. 修改元素](#3. 修改元素)
  - [4. 容量和长度](#4. 容量和长度)
  - [5. 遍历](#5. 遍历)
  - [6. 内存安全](#6. 内存安全)
  - [7. 性能](#7. 性能)

在Rust编程语言中，Vec<T> 是标准库中提供的动态数组类型，它是最常用的数据结构之一。Vec<T> 是一个泛型类型，T 表示数组中元素的类型。

1. 创建Vector

使用vec!宏
rust 复制代码
```
let v: Vec<i32> = vec![1,2,3,4,5]
```
vec!宏是一个方便的语法糖，用于初始化包含指定元素的Vec
使用 Vec::new 方法
rust 复制代码
```
let v: Vec<i32> = Vec:new();
```
这将创建一个空的 Vec。Vec::new 返回一个默认初始化的 Vec，没有分配任何内存空间。
使用 Vec::with_capacity 方法
rust 复制代码
```
let v: Vec<i32> = Vec:with_capacity(10);
```
创建一个具有指定容量的 Vec，但它是空的。预先分配容量可以避免在添加元素时频繁地重新分配内存

2. 访问

通过索引访问元素

rust 复制代码

let v = vec![1, 2, 3, 4, 5];
let first = &v[0];
let second = &mut v[1];

索引访问可能会导致运行时错误（例如，如果索引超出范围），所以通常会使用 Result 或 Option 来处理这种情况

3. 修改元素

通过push方法添加元素

rust 复制代码

let mut v = Vec::new();
v.psuh(1);
v.push(2);

通过insert方法在指定位置插入元素
rust 复制代码
```
let mut v = vec![1,2,4];
v.insert(2, 3);
// [1,2,3,4]
```

通过remove方法移除元素

rust 复制代码

let mut v = vec![1, 2, 3, 4]
let removed = v.remove(1)

4. 容量和长度

rust 复制代码

// 获取长度
let v = vec![1, 2, 3, 4, 5];
let len = v.len(); // 结果是 5

// 获取容量
let v = vec![1, 2, 3, 4, 5];
let capacity = v.capacity(); // 返回当前分配的容量

// 预留容量
let mut v = vec![1, 2, 3];
v.reserve(10); // 预留额外的 10 个元素的容量

// 收缩到适合容量
let mut v = vec![1, 2, 3, 4, 5];
v.shrink_to_fit();

5. 遍历

使用 for 循环：

rust 复制代码

let v = vec![1, 2, 3, 4, 5];
for &x in &v {
    println!("{}", x);

}

使用迭代器：

rust 复制代码

let v = vec![1, 2, 3, 4, 5];
for x in v.iter() {
    println!("{}", x);

}

使用 enumerate 方法：

rust 复制代码

let v = vec![1, 2, 3, 4, 5];
for (i, &x) in v.iter().enumerate() {
    println!("Element at index {}: {}", i, x);
}

6. 内存安全

Rust 的 Vec<T> 是内存安全的，因为它在编译时确保了以下几点：

边界检查 ：访问 Vec 元素时会进行边界检查，以防止越界访问。
所有权 ：Vec 遵循 Rust 的所有权规则，确保了内存不会被重复释放或未释放。
不可变性 ：默认情况下，Vec 是不可变的，需要使用 mut 关键字来声明可变 Vec。

7. 性能

动态数组 ：Vec<T> 底层实现为动态数组，因此在添加或移除元素时可能会涉及内存重新分配。然而，Rust 的内存分配器相对高效，且 Vec 提供了预留容量的方法来减少重新分配的次数。
缓存友好 ：由于 Vec<T> 是连续存储的，所以它是缓存友好的，适合用于需要高效访问元素的数据结构。