Arrays 我可以得到一个锈菌阵列'；只有一个类型而不是具体变量的s长度？ 我想把下面的C++代码改写为RIST:< /P> 使用存储=数组； const size\u t storage\u len=sizeof（storage）/sizeof（storage:：value\u type）；

如果没有具体的变量，我怎么能得到那个恒定的长度值呢

作为动机，尽管这看起来很简单，但我想打印数组的元素计数，而不声明变量。我知道我可以使用一个常量值或声明一个哑变量，但是我不知道RISC如何保存C++代码。

---

我承认没有具体的变量是不清楚的。我想实现上述C++特性，但这种解释可能会误导。我很好奇是否有任何方法可以获得数组的元素类型。

在Rust中，可以使用获得类型的大小，因此可以使用与C++中相同的方法获得数组类型的长度：

use std::mem::size_of;

type Storage = [i32; 3];

fn main() {
    println!("Length: {}", size_of::<Storage>() / size_of::<i32>());
}

使用std:：mem:：size\u of；
类型存储=[i32；3]；
fn main（）{
println！（（“长度：{}”，大小：：（）/大小：：（））；
}

但是，这需要知道存储在数组中的项的类型。我不知道如何在不实例化变量的情况下获得它。

您可以使用：

let storage_len=std:：mem:：size_of:：（）/std:：mem:：size_of:：（）；

强制到，因此切片上可用的任何方法在阵列上也可用。比如：

---

Rust现在支持const泛型。我留下了旧的答案，这样人们就会知道为什么一开始会有人问这个问题

自Rust 1.51以来的新答案：

pub特征长度{
常数：使用；
}
[T；长度]{
常量长度：usize=长度；
}

旧答案：

我知道您只想从类型信息中检索数组长度。Rust没有内置的PI类型（也称为const泛型）。这意味着该语言当前不支持非类型（如数组长度的整数）的泛型参数

虽然不是在不久的将来，但在未来，我们很可能会看到对它的支持

如果必须这样做，您可以通过为每种类型实现一个特征来克服该限制：

trait GetLength {
    fn len() -> usize;
}

impl<T> GetLength for [T; 0] {
    fn len() -> usize {
        0
    }
}

impl<T> GetLength for [T; 1] {
    fn len() -> usize {
        1
    }
}

// ...

fn main() {
    println!("{}", <[String; 1]>::len());
}

trait GetLength{
fn len（）->usize；
}
[T；0]的impl GetLength{
fn len（）->usize{
0
}
}
[T；1]的impl GetLength{
fn len（）->usize{
1.
}
}
// ...
fn main（）{
println！（“{}，：：len（））；
}

宏有助于防止重复键入：

trait GetLength {
    fn len() -> usize;
}

macro_rules! impl_get_length {
    ($v:expr) => {
        impl<T> GetLength for [T; $v] {
            fn len() -> usize {
                $v
            }
        }
    };
}

impl_get_length!{ 0 }
impl_get_length!{ 1 }

// ...

fn main() {
    println!("{}", <[String; 1]>::len());
}

trait GetLength{
fn len（）->usize；
}
宏规则！impl_get_长度{
（$v:expr）=>{
[T；$v]的impl GetLength{
fn len（）->usize{
$v
}
}
};
}
求长度！{ 0 }
求长度！{ 1 }
// ...
fn main（）{
println！（“{}，：：len（））；
}

类似的板条箱也有助于在现有语言中为const泛型提供一些支持。

只是为了好玩：

use std::mem;
use std::ops::Deref;

fn main() {
    assert_eq!(5, num_elems::<[i32; 5]>());
}

fn num_elems<T>() -> usize 
where 
    T: 'static, 
    &'static T: IntoIterator,
    <&'static T as IntoIterator>::Item: Deref,
    <<&'static T as IntoIterator>::Item as Deref>::Target: Sized,
{
    fn inner<S, I>() -> usize 
    where 
        I: Deref,
        <I as Deref>::Target: Sized,
    { 
        mem::size_of::<S>() / mem::size_of::<I::Target>()
    }

    inner::<T, <&'static T as IntoIterator>::Item>()
}

使用std:：mem；
使用std:：ops:：Deref；
fn main（）{
断言（5，元素数：：（））；
}
fn num_elems（）->usize
哪里
T:静态，
&'static T:into迭代器，
：：项目为Deref>：：目标：大小，
{
fn inner（）->usize
哪里
I:德里夫，
：：目标：大小，
{ 
mem:：size_of:：（）/mem:：size_of:：（）
}
内部：：你的问题有点误导。你说“没有具体变量”是什么意思？你能澄清你的问题吗？对于所有说“只使用（x）/y的
size\u
，请尝试
size\u of:：（）/size\u of:：（）
@hellow他们没有说
x
和
y
，但是
[i32；3]
和
i32
，这很好。我想知道你为什么需要这样的功能。我想他想知道const泛型。你没有回答这个问题：OP要求在没有具体变量的情况下得到结果。@Stargateur这可以用在泛型代码中，尽管我也不能给出实际的用例。不是吗这是一个除以零的值，可能是：<代码>（）<代码>的大小：：<代码>，不，从头开始。数组依赖于一个非大小强制来实现<代码>索引。我不知道如何表示项类型。
trait GetLength {
    fn len() -> usize;
}

macro_rules! impl_get_length {
    ($v:expr) => {
        impl<T> GetLength for [T; $v] {
            fn len() -> usize {
                $v
            }
        }
    };
}

impl_get_length!{ 0 }
impl_get_length!{ 1 }

// ...

fn main() {
    println!("{}", <[String; 1]>::len());
}

use std::mem;
use std::ops::Deref;

fn main() {
    assert_eq!(5, num_elems::<[i32; 5]>());
}

fn num_elems<T>() -> usize 
where 
    T: 'static, 
    &'static T: IntoIterator,
    <&'static T as IntoIterator>::Item: Deref,
    <<&'static T as IntoIterator>::Item as Deref>::Target: Sized,
{
    fn inner<S, I>() -> usize 
    where 
        I: Deref,
        <I as Deref>::Target: Sized,
    { 
        mem::size_of::<S>() / mem::size_of::<I::Target>()
    }

    inner::<T, <&'static T as IntoIterator>::Item>()
}