For loop 如何在For循环中创建向量向量？

我试图用for循环创建一个向量向量。我尝试过下面的设计，但没有成功：

// num_partitions is the primary vector, v is vector that contains a set of integers
// This function should return a Primary Vector that hold num_partitions of vectors

fn partition_data(num_partitions: usize, v: &Vec<usize>) -> Vec<Vec<usize>> {
    let partition_size = v.len() / num_partitions;

    // Create a vector that will contain vectors of integers
    let mut xs: Vec<Vec<usize>> = Vec::new();
 
    for j in 0..partition_size {
        for i in 0..partition_size {
            // create a new Vector and push elements to it
            let mut x1: Vec<usize> = Vec::new();
            x1.push(v[i]);
        }
        // push this new Vector the the Primary Vector
        xs.push(x1);
    }
   
    // return primary vector
    xs
}

//num\u partitions是主向量，v是包含一组整数的向量
//此函数应返回一个主向量，该主向量包含向量的num_分区
fn partition\u data（num\u partitions:usize，v:&Vec）->Vec{
让partition_size=v.len（）/num_partitions；
//创建一个包含整数向量的向量
让mut-xs:Vec=Vec:：new（）；
对于0.分区大小中的j{
对于0.分区大小中的i{
//创建一个新向量并将元素推送到该向量
让mut-x1:Vec=Vec:：new（）；
x1.推力（v[i]）；
}
//将此新向量推送到主向量
x.推力（x1）；
}
//返回主向量
xs
}

Rust标准库中有一些方便的函数，它们已经完成了您只需使用迭代器即可轻松实现此函数所需的大部分工作：

fn partition\u data（num\u partitions:usize，v:&Vec）->Vec{
让partition_size=v.len（）/num_partitions；
v、 块（分区大小）
.map（| chunk | chunk.to_vec（））
.collect（）
}

---

Rust标准库中有一些方便的函数，它们已经完成了您只需使用迭代器即可轻松实现此函数所需的大部分工作：

fn partition\u data（num\u partitions:usize，v:&Vec）->Vec{
让partition_size=v.len（）/num_partitions；
v、 块（分区大小）
.map（| chunk | chunk.to_vec（））
.collect（）
}

---

以下是您的问题的简化示例：

let mut outer_vec:vec=vec:：new（）；
对于0..5中的j{
对于0..5{
让mut internal_vec:vec=vec:：new（）；
内向量推送（1）；
}
外推（内推）；
}

internal_vec

在

for

循环的内部

中声明<代码>外部向量

在外部

for

循环中声明。由于生锈，

内部

在其作用域（内部

for

循环）的末端被破坏，因此外部作用域（外部

for

循环）无法访问它：

0..5中的i的

{
让mut internal_vec:vec=vec:：new（）；
//从这里开始，内部向量是有效的^
内向量推送（1）；
//内部向量在这里被破坏，它的内存被释放
}
//内部_vec现在不存在，因此此操作失败：
外推（内推）；

要解决此问题，您可以在外部范围中声明

internal\u vec

：

让mut-inner_-vec:vec=vec:：new（）；
因为我在0..5{
内向量推送（1）；
}
//内部_-vec和外部_-vec现在在同一范围内，因此这很好：
外推（内推）；

以下是您的问题的简化示例：

let mut outer_vec:vec=vec:：new（）；
对于0..5中的j{
对于0..5{
让mut internal_vec:vec=vec:：new（）；
内向量推送（1）；
}
外推（内推）；
}

internal_vec

在

for

循环的内部

中声明<代码>外部向量

在外部

for

循环中声明。由于生锈，

内部

在其作用域（内部

for

循环）的末端被破坏，因此外部作用域（外部

for

循环）无法访问它：

0..5中的i的

{
让mut internal_vec:vec=vec:：new（）；
//从这里开始，内部向量是有效的^
内向量推送（1）；
//内部向量在这里被破坏，它的内存被释放
}
//内部_vec现在不存在，因此此操作失败：
外推（内推）；

要解决此问题，您可以在外部范围中声明

internal\u vec

：

让mut-inner_-vec:vec=vec:：new（）；
因为我在0..5{
内向量推送（1）；
}
//内部_-vec和外部_-vec现在在同一范围内，因此这很好：
外推（内推）；

您实际上没有解释问题是什么，也没有提供重新编译案例，但是我希望不会编译，因为Rust严格受块范围限制。因为您在最内层循环中声明了

x1

，所以它只在所述最内层循环的一次迭代中存在。这个声明需要提升一个范围。除此之外，你的代码没有多大意义：它只是要创建

分区大小

向量，所有向量都包含输入向量中的第一个

分区大小

项。而输入

&Vec

通常没有用处，

&t]

提供了更大的调用灵活性，没有缺点。

x1

应该在

的外部
循环中声明，而不是在内部循环中声明。这可能无法编译，因为
xs.push（x1）
引用的变量不在该范围内。这不是一个锈迹特定的问题，在爪哇、Python、C++等中，你会有相同或类似的问题。你实际上不解释这个问题是什么，或者提供一个替代案例，但是我希望不编译为锈是严格的块范围。因为您在最内层循环中声明了
x1
，所以它只在所述最内层循环的一次迭代中存在。这个声明需要提升一个范围。除此之外，你的代码没有多大意义：它只是要创建
分区大小
向量，所有向量都包含输入向量中的第一个
分区大小
项。而输入
&Vec
通常没有用处，
&t]
提供了更大的调用灵活性，没有缺点。
x1
应该在
的外部
循环中声明，而不是在内部循环中声明。这可能无法编译，因为
xs.push（x1）
引用的变量不在该范围内。这不是一个锈蚀特定的问题，在爪哇、Python、C++等中，你会遇到相同或相似的问题。