Rust 线​​程 'main' 已溢出其堆栈

Question

我正在尝试重新实现此 C 代码:

#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>

#define ROWS 100000
#define COLS 10000

int twodarray[ROWS][COLS];

int main() {
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            twodarray[i][j] = rand();
        }
    }

    int64 sum = 0;
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            sum += twodarray[i][j];
        }
    }
}

所以，经过大量的试验和错误，我想出了至少可以编译的 Rust 代码

extern crate rand;

const ROWS: usize = 100000;
const COLS: usize = 10000;

fn main() {
    let mut twodarray: [[u128; COLS]; ROWS] = [[0; COLS]; ROWS];

    for i in 0..ROWS {
        for j in 0..COLS {
            twodarray[i][j] = rand::random::<u8>() as u128;
        }
    }

    let mut sum: u128 = 0;
    for k in 0..ROWS {
        for j in 0..COLS {
            sum += twodarray[k][j] as u128;
        }
    }
    println!("{}", sum);
}

但是当我编译并执行它时，我收到以下错误消息:线程“main”已溢出其堆栈。老实说，我完全不知道为什么会发生这种情况。我目前正在学习 Rust，但是网上没有很多关于二维数组的信息...我不想使用 VECTOR。本练习专门针对数组。

编辑: 在阅读了接受的答案后，我想出了输出预期结果的 Rust 代码:

extern crate rand;

const ROWS: usize = 100000;
const COLS: usize = 10000;

fn main() {
    // let mut twodarray: Box<[[u8; COLS]; ROWS]> = Box::new([[0; COLS]; ROWS]);
    // for i in 0..ROWS {
    //     for j in 0..COLS {
    //         twodarray[i][j] = rand::random::<u8>();
    //     }
    // }

    // let mut sum: u32 = 0;
    // for k in 0..ROWS {
    //     for l in 0..COLS {
    //         sum += twodarray[k][l] as u32;
    //     }
    // }

    let mut twodarray: Box<[[u8; ROWS]; COLS]> = Box::new([[0; ROWS]; COLS]);
    for i in 0..COLS {
        for j in 0..ROWS {
            twodarray[i][j] = rand::random::<u8>();
        }
    }

    let mut sum: u32 = 0;
    for k in 0..COLS {
        for l in 0..ROWS {
            sum += twodarray[k][l] as u32;
        }
    }
    println!("{}", sum);
}

Answer 1

这个二维数组很大。 Rust 尝试在堆栈上分配它(这就是 Rust 中数组的工作方式)。

您明确写道您不想使用向量，但实际上向量是在堆上分配的，因此您不会遇到这样的问题。记住这一点是件好事。

如果您坚持使用数组，也许可以将它们放入 Box 中，以便它们进入堆？

这不是 Rust 特有的问题。与堆相比，堆栈通常受到更多限制，通常最多几兆字节。在其他一些语言中，例如 Java，数组是在堆上分配的，但这并不意味着那里也没有类似的堆栈大小限制。