Vector 在读取2D向量时，如何消除临时向量？

我有一个二维向量的代码。有没有办法消除对

temp\u vec

的需求

let mut vec_size: usize = 3;
let mut vec = vec![vec![0; vec_size]; vec_size];   
for i in 0..vec_size{
    input = String::new();
    io::stdin().read_line(&mut input).expect("Failed to read");
    let temp_vec: Vec<i32> = input
             .split_whitespace()
             .map(|s| s.parse().unwrap())
             .collect();
    for j in 0..temp_vec.len(){
        vec[i][j] = temp_vec[j];
    }
}

让mut vec_size:usize=3；
让mut-vec=vec！[vec！[0；vec_size]；vec_size]；
对于0..vec\u大小的i{
input=String:：new（）；
io:：stdin（）.read_行（&mut输入）。预期（“读取失败”）；
设温度向量：向量=输入
.split_空格（）
.map（| s | s.parse（）.unwrap（））
.收集（）；
对于0..temp_vec.len（）中的j{
向量[i][j]=临时向量[j]；
}
}

将标准输入的行映射为行，然后将每行中的数字映射为列

use std::io;
use std::io::prelude::*;

const SIZE: usize = 3;

fn main() {
    let stdin = io::stdin();
    let vec: Vec<Vec<i32>> = stdin.lock()
        .lines()
        .take(SIZE)
        .map(|line| {
            let line = line.expect("Unable to read line");
            line.split_whitespace()
                .take(SIZE)
                .map(|s| s.parse().expect("Enable to parse number"))
                .collect()
        })
        .collect();

    println!("{:?}", vec);
}

使用std:：io；
使用std:：io:：prelude:：*；
常数大小：usize=3；
fn main（）{
设stdin=io:：stdin（）；
设vec:vec=stdin.lock（）
.行（）
.拿（尺码）
.地图（|线|{
let line=line.expect（“无法读取行”）；
line.split_空格（）
.拿（尺码）
.map（| s | s.parse（）.expect（“启用解析数字”））
.collect（）
})
.收集（）；
println！（“{：？}”，vec）；
}

或者如果你不想惊慌：

use std::io;
use std::io::prelude::*;
use std::error::Error;

const SIZE: usize = 3;

fn main() {
    let stdin = io::stdin();
    let vec: Result<Vec<Vec<i32>>, _> = stdin.lock()
        .lines()
        .take(SIZE)
        .map(|line| {
            line.map_err(|e| Box::new(e) as Box<Error>)
                .and_then(|line| {
                    line.split_whitespace()
                        .take(SIZE)
                        .map(|s| s.parse().map_err(|e| Box::new(e) as Box<Error>))
                        .collect()
                })
        })
        .collect();

    println!("{:?}", vec);
}

使用std:：io；
使用std:：io:：prelude:：*；
使用std:：error:：error；
常数大小：usize=3；
fn main（）{
设stdin=io:：stdin（）；
让vec:Result=stdin.lock（）
.行（）
.拿（尺码）
.地图（|线|{
line.map_err（| e | Box:：new（e）as Box）
.然后|行|{
line.split_空格（）
.拿（尺码）
.map（|s | s.parse（）.map|err（| e | Box:：new（e）as Box））
.collect（）
})
})
.收集（）；
println！（“{：？}”，vec）；
}

---

从评论中解决问题：

您的代码进行2n+1分配（如果有人在寻找性能，这一点很重要）

不清楚这里的

N

是什么，但是应该最多分配3个向量，每个向量中应该有3个项。

take

适配器将覆盖

size\u提示，最多放置
3
，然后
collect
将在构建每个
Vec
时使用该提示

对矩阵使用嵌套的
Vec
s是一种反模式

当然，但这就是原始代码所做的

您“破坏”了stdin–调用
lock（）.lines（）后无法可靠地使用它

我不知道你在这里的意思。我可以在定义
let vec
的代码块之后添加
stdin.read（&mut[0,0,0]）。expect（“无法读取更多”）
，表明它可以使用

如果无法使用stdin时出现问题，可以通过将锁的作用域限定到较早结束的块来解决此问题。
I如果删除
collect（）
调用，将得到一个迭代器，您可以
enumerate（）
并将其传递到for循环：

use std::io;

fn main() {
    let vec_size: usize = 3;
    let mut vec = vec![vec![0; vec_size]; vec_size];   
    let mut input = String::new();
    for i in 0..vec_size {
        input.clear();
        io::stdin().read_line(&mut input).expect("Failed to read");
        let numbers = input
            .split_whitespace()
            .map(|s| s.parse().unwrap());
        for (j, x) in numbers.enumerate() {
            vec[i][j] = x;
        }
    }
}

此代码还调用
clear（）
来清除输入缓冲区，而不是分配新字符串，因此它只进行一次额外的分配（如果您正在读取大量小矩阵，您可能会从中受益）

（关于代码的旁注：如果可以，最好使用
.iter（）.enumerate（）
而不是迭代向量索引）


在写这个答案时，我误解了原来的问题，认为有一个堆栈分配矩阵：

const VEC_SIZE: usize = 3;
let mut vec = [[0; VEC_SIZE]; VEC_SIZE];

如果是这样的话，我会推荐我的解决方案，但由于它是一个
Vec
，我会推荐@Shepmaster的解决方案，因为它更为惯用。
谢谢！似乎你在回答我所有与生锈有关的问题，也许他们应该将网站改为Shepmaster exchange:）@KDN nah；我只是在这里花了太多时间。有很多人可以做出比我更好的答案，但他们正在做其他事情。还有很多地方我甚至不能提供一个有用的答案！