Struct alloc::boxed::Box

1.0.0 · source ·
pub struct Box<T: ?Sized, A: Allocator = Global>(_, _);
Expand description

唯一拥有 T 类型堆分配的指针类型。

有关更多信息,请参见 模块级文档

Implementations§

source§

impl<T> Box<T>

source

pub fn new(x: T) -> Self

在堆上分配内存,然后将 x 放入其中。

如果 T 的大小为零,则实际上不会分配。

Examples
let five = Box::new(5);
Run
source

pub fn new_uninit() -> Box<MaybeUninit<T>>

🔬This is a nightly-only experimental API. (new_uninit #63291)

创建一个具有未初始化内容的新 box。

Examples
#![feature(new_uninit)]

let mut five = Box::<u32>::new_uninit();

let five = unsafe {
    // 延迟初始化:
    five.as_mut_ptr().write(5);

    five.assume_init()
};

assert_eq!(*five, 5)
Run
source

pub fn new_zeroed() -> Box<MaybeUninit<T>>

🔬This is a nightly-only experimental API. (new_uninit #63291)

创建一个具有未初始化内容的新 Box,并用 0 字节填充内存。

有关正确和不正确使用此方法的示例,请参见 MaybeUninit::zeroed

Examples
#![feature(new_uninit)]

let zero = Box::<u32>::new_zeroed();
let zero = unsafe { zero.assume_init() };

assert_eq!(*zero, 0)
Run
1.33.0 · source

pub fn pin(x: T) -> Pin<Box<T>>

创建一个新的 Pin<Box<T>>。如果 T 没有实现 Unpin,那么 x 将被固定在内存中并且无法移动。

Box 的构建和固定也可以分两步完成: Box::pin(x)Box::into_pin(Box::new(x)) 相同。 如果您已经有 Box<T>,或者如果您想以与 Box::new 不同的方式构建 (pinned) Box,请考虑使用 into_pin

source

pub fn try_new(x: T) -> Result<Self, AllocError>

🔬This is a nightly-only experimental API. (allocator_api #32838)

在堆上分配内存,然后将 x 放入其中,如果分配失败,则返回错误

如果 T 的大小为零,则实际上不会分配。

Examples
#![feature(allocator_api)]

let five = Box::try_new(5)?;
Run
source

pub fn try_new_uninit() -> Result<Box<MaybeUninit<T>>, AllocError>

🔬This is a nightly-only experimental API. (allocator_api #32838)

在堆上创建一个具有未初始化内容的新 box,如果分配失败,则返回错误

Examples
#![feature(allocator_api, new_uninit)]

let mut five = Box::<u32>::try_new_uninit()?;

let five = unsafe {
    // 延迟初始化:
    five.as_mut_ptr().write(5);

    five.assume_init()
};

assert_eq!(*five, 5);
Run
source

pub fn try_new_zeroed() -> Result<Box<MaybeUninit<T>>, AllocError>

🔬This is a nightly-only experimental API. (allocator_api #32838)

创建一个具有未初始化内容的新 Box,堆中的内存由 0 字节填充

有关正确和不正确使用此方法的示例,请参见 MaybeUninit::zeroed

Examples
#![feature(allocator_api, new_uninit)]

let zero = Box::<u32>::try_new_zeroed()?;
let zero = unsafe { zero.assume_init() };

assert_eq!(*zero, 0);
Run
source§

impl<T, A: Allocator> Box<T, A>

source

pub fn new_in(x: T, alloc: A) -> Selfwhere A: Allocator,

🔬This is a nightly-only experimental API. (allocator_api #32838)

在给定的分配器中分配内存,然后将 x 放入其中。

如果 T 的大小为零,则实际上不会分配。

Examples
#![feature(allocator_api)]

use std::alloc::System;

let five = Box::new_in(5, System);
Run
source

pub fn try_new_in(x: T, alloc: A) -> Result<Self, AllocError>where A: Allocator,

🔬This is a nightly-only experimental API. (allocator_api #32838)

在给定的分配器中分配内存,然后将 x 放入其中,如果分配失败,则返回错误

如果 T 的大小为零,则实际上不会分配。

Examples
#![feature(allocator_api)]

use std::alloc::System;

let five = Box::try_new_in(5, System)?;
Run
source

pub fn new_uninit_in(alloc: A) -> Box<MaybeUninit<T>, A>where A: Allocator,

🔬This is a nightly-only experimental API. (allocator_api #32838)

在提供的分配器中创建一个具有未初始化内容的新 box。

Examples
#![feature(allocator_api, new_uninit)]

use std::alloc::System;

let mut five = Box::<u32, _>::new_uninit_in(System);

let five = unsafe {
    // 延迟初始化:
    five.as_mut_ptr().write(5);

    five.assume_init()
};

assert_eq!(*five, 5)
Run
source

pub fn try_new_uninit_in(alloc: A) -> Result<Box<MaybeUninit<T>, A>, AllocError>where A: Allocator,

🔬This is a nightly-only experimental API. (allocator_api #32838)

在提供的分配器中创建一个具有未初始化内容的新 box,如果分配失败,则返回错误

Examples
#![feature(allocator_api, new_uninit)]

use std::alloc::System;

let mut five = Box::<u32, _>::try_new_uninit_in(System)?;

let five = unsafe {
    // 延迟初始化:
    five.as_mut_ptr().write(5);

    five.assume_init()
};

assert_eq!(*five, 5);
Run
source

pub fn new_zeroed_in(alloc: A) -> Box<MaybeUninit<T>, A>where A: Allocator,

🔬This is a nightly-only experimental API. (allocator_api #32838)

创建一个具有未初始化内容的新 Box,使用提供的分配器中的 0 字节填充内存。

有关正确和不正确使用此方法的示例,请参见 MaybeUninit::zeroed

Examples
#![feature(allocator_api, new_uninit)]

use std::alloc::System;

let zero = Box::<u32, _>::new_zeroed_in(System);
let zero = unsafe { zero.assume_init() };

assert_eq!(*zero, 0)
Run
source

pub fn try_new_zeroed_in(alloc: A) -> Result<Box<MaybeUninit<T>, A>, AllocError>where A: Allocator,

🔬This is a nightly-only experimental API. (allocator_api #32838)

创建一个具有未初始化内容的新 Box,使用提供的分配器中的 0 字节填充内存,如果分配失败,则返回错误,

有关正确和不正确使用此方法的示例,请参见 MaybeUninit::zeroed

Examples
#![feature(allocator_api, new_uninit)]

use std::alloc::System;

let zero = Box::<u32, _>::try_new_zeroed_in(System)?;
let zero = unsafe { zero.assume_init() };

assert_eq!(*zero, 0);
Run
source

pub fn pin_in(x: T, alloc: A) -> Pin<Self>where A: 'static + Allocator,

🔬This is a nightly-only experimental API. (allocator_api #32838)

创建一个新的 Pin<Box<T, A>>。如果 T 没有实现 Unpin,那么 x 将被固定在内存中并且无法移动。

Box 的构建和固定也可以分两步完成: Box::pin_in(x, alloc)Box::into_pin(Box::new_in(x, alloc)) 相同。 如果您已经有 Box<T, A>,或者如果您想以与 Box::new_in 不同的方式构建 (pinned) Box,请考虑使用 into_pin

source

pub fn into_boxed_slice(boxed: Self) -> Box<[T], A>

🔬This is a nightly-only experimental API. (box_into_boxed_slice #71582)

Box<T> 转换为 Box<[T]>

这种转换不会在堆上分配,而是就地进行。

source

pub fn into_inner(boxed: Self) -> T

🔬This is a nightly-only experimental API. (box_into_inner #80437)

消耗 Box,返回包装的值。

Examples
#![feature(box_into_inner)]

let c = Box::new(5);

assert_eq!(Box::into_inner(c), 5);
Run
source§

impl<T> Box<[T]>

source

pub fn new_uninit_slice(len: usize) -> Box<[MaybeUninit<T>]>

🔬This is a nightly-only experimental API. (new_uninit #63291)

创建一个具有未初始化内容的新 boxed 切片。

Examples
#![feature(new_uninit)]

let mut values = Box::<[u32]>::new_uninit_slice(3);

let values = unsafe {
    // 延迟初始化:
    values[0].as_mut_ptr().write(1);
    values[1].as_mut_ptr().write(2);
    values[2].as_mut_ptr().write(3);

    values.assume_init()
};

assert_eq!(*values, [1, 2, 3])
Run
source

pub fn new_zeroed_slice(len: usize) -> Box<[MaybeUninit<T>]>

🔬This is a nightly-only experimental API. (new_uninit #63291)

创建一个具有未初始化内容的新 boxed 切片,并用 0 字节填充内存。

有关正确和不正确使用此方法的示例,请参见 MaybeUninit::zeroed

Examples
#![feature(new_uninit)]

let values = Box::<[u32]>::new_zeroed_slice(3);
let values = unsafe { values.assume_init() };

assert_eq!(*values, [0, 0, 0])
Run
source

pub fn try_new_uninit_slice( len: usize ) -> Result<Box<[MaybeUninit<T>]>, AllocError>

🔬This is a nightly-only experimental API. (allocator_api #32838)

创建一个具有未初始化内容的新 boxed 切片。 如果分配失败,则返回一个错误

Examples
#![feature(allocator_api, new_uninit)]

let mut values = Box::<[u32]>::try_new_uninit_slice(3)?;
let values = unsafe {
    // 延迟初始化:
    values[0].as_mut_ptr().write(1);
    values[1].as_mut_ptr().write(2);
    values[2].as_mut_ptr().write(3);
    values.assume_init()
};

assert_eq!(*values, [1, 2, 3]);
Run
source

pub fn try_new_zeroed_slice( len: usize ) -> Result<Box<[MaybeUninit<T>]>, AllocError>

🔬This is a nightly-only experimental API. (allocator_api #32838)

创建一个具有未初始化内容的新 boxed 切片,并用 0 字节填充内存。 如果分配失败,则返回一个错误

有关正确和不正确使用此方法的示例,请参见 MaybeUninit::zeroed

Examples
#![feature(allocator_api, new_uninit)]

let values = Box::<[u32]>::try_new_zeroed_slice(3)?;
let values = unsafe { values.assume_init() };

assert_eq!(*values, [0, 0, 0]);
Run
source§

impl<T, A: Allocator> Box<[T], A>

source

pub fn new_uninit_slice_in(len: usize, alloc: A) -> Box<[MaybeUninit<T>], A>

🔬This is a nightly-only experimental API. (allocator_api #32838)

使用提供的分配器中未初始化的内容创建一个新的 boxed 切片。

Examples
#![feature(allocator_api, new_uninit)]

use std::alloc::System;

let mut values = Box::<[u32], _>::new_uninit_slice_in(3, System);

let values = unsafe {
    // 延迟初始化:
    values[0].as_mut_ptr().write(1);
    values[1].as_mut_ptr().write(2);
    values[2].as_mut_ptr().write(3);

    values.assume_init()
};

assert_eq!(*values, [1, 2, 3])
Run
source

pub fn new_zeroed_slice_in(len: usize, alloc: A) -> Box<[MaybeUninit<T>], A>

🔬This is a nightly-only experimental API. (allocator_api #32838)

使用提供的分配器中未初始化的内容创建一个新的 boxed 切片,并用 0 字节填充内存。

有关正确和不正确使用此方法的示例,请参见 MaybeUninit::zeroed

Examples
#![feature(allocator_api, new_uninit)]

use std::alloc::System;

let values = Box::<[u32], _>::new_zeroed_slice_in(3, System);
let values = unsafe { values.assume_init() };

assert_eq!(*values, [0, 0, 0])
Run
source§

impl<T, A: Allocator> Box<MaybeUninit<T>, A>

source

pub unsafe fn assume_init(self) -> Box<T, A>

🔬This is a nightly-only experimental API. (new_uninit #63291)

转换为 Box<T, A>

Safety

MaybeUninit::assume_init 一样,由调用者负责确保该值确实处于初始化状态。

在内容尚未完全初始化时调用此方法会立即导致未定义的行为。

Examples
#![feature(new_uninit)]

let mut five = Box::<u32>::new_uninit();

let five: Box<u32> = unsafe {
    // 延迟初始化:
    five.as_mut_ptr().write(5);

    five.assume_init()
};

assert_eq!(*five, 5)
Run
source

pub fn write(boxed: Self, value: T) -> Box<T, A>

🔬This is a nightly-only experimental API. (new_uninit #63291)

写入值并转换为 Box<T, A>

这种方法将 box 转换成和 Box::assume_init 类似的形式,只是在转换前将 value 写入其中,从而保证了安全性。

在某些情况下,使用此方法可能会提高性能,因为编译器可能能够优化从栈复制。

Examples
#![feature(new_uninit)]

let big_box = Box::<[usize; 1024]>::new_uninit();

let mut array = [0; 1024];
for (i, place) in array.iter_mut().enumerate() {
    *place = i;
}

// 优化器可能会忽略此副本,所以以前的代码直接写入到堆中。
let big_box = Box::write(big_box, array);

for (i, x) in big_box.iter().enumerate() {
    assert_eq!(*x, i);
}
Run
source§

impl<T, A: Allocator> Box<[MaybeUninit<T>], A>

source

pub unsafe fn assume_init(self) -> Box<[T], A>

🔬This is a nightly-only experimental API. (new_uninit #63291)

转换为 Box<[T], A>

Safety

MaybeUninit::assume_init 一样,由调用者负责确保值确实处于初始化状态。

在内容尚未完全初始化时调用此方法会立即导致未定义的行为。

Examples
#![feature(new_uninit)]

let mut values = Box::<[u32]>::new_uninit_slice(3);

let values = unsafe {
    // 延迟初始化:
    values[0].as_mut_ptr().write(1);
    values[1].as_mut_ptr().write(2);
    values[2].as_mut_ptr().write(3);

    values.assume_init()
};

assert_eq!(*values, [1, 2, 3])
Run
source§

impl<T: ?Sized> Box<T>

1.4.0 · source

pub unsafe fn from_raw(raw: *mut T) -> Self

从裸指针构造一个 box。

调用此函数后,结果 Box 拥有裸指针。 具体来说,Box 析构函数将调用 T 的析构函数并释放分配的内存。 为了安全起见,必须根据 Box 所使用的 内存布局 分配内存。

Safety

此函数不安全,因为使用不当可能会导致内存问题。 例如,如果在同一裸指针上两次调用该函数,则可能会出现 double-free。

安全条件在 内存布局 部分中进行了描述。

Examples

重新创建以前使用 Box::into_raw 转换为裸指针的 Box

let x = Box::new(5);
let ptr = Box::into_raw(x);
let x = unsafe { Box::from_raw(ptr) };
Run

使用二进制分配器从头开始手动创建 Box

use std::alloc::{alloc, Layout};

unsafe {
    let ptr = alloc(Layout::new::<i32>()) as *mut i32;
    // 通常,需要 .write 以避免尝试销毁 `ptr` 以前的内容,尽管对于这个简单的示例 `*ptr = 5` 也可以工作。
    ptr.write(5);
    let x = Box::from_raw(ptr);
}
Run
source§

impl<T: ?Sized, A: Allocator> Box<T, A>

const: unstable · source

pub unsafe fn from_raw_in(raw: *mut T, alloc: A) -> Self

🔬This is a nightly-only experimental API. (allocator_api #32838)

从给定分配器中的裸指针构造 box。

调用此函数后,结果 Box 拥有裸指针。 具体来说,Box 析构函数将调用 T 的析构函数并释放分配的内存。 为了安全起见,必须根据 Box 所使用的 内存布局 分配内存。

Safety

此函数不安全,因为使用不当可能会导致内存问题。 例如,如果在同一裸指针上两次调用该函数,则可能会出现 double-free。

Examples

重新创建以前使用 Box::into_raw_with_allocator 转换为裸指针的 Box

#![feature(allocator_api)]

use std::alloc::System;

let x = Box::new_in(5, System);
let (ptr, alloc) = Box::into_raw_with_allocator(x);
let x = unsafe { Box::from_raw_in(ptr, alloc) };
Run

使用系统分配器从头开始手动创建 Box

#![feature(allocator_api, slice_ptr_get)]

use std::alloc::{Allocator, Layout, System};

unsafe {
    let ptr = System.allocate(Layout::new::<i32>())?.as_mut_ptr() as *mut i32;
    // 通常,需要 .write 以避免尝试销毁 `ptr` 以前的内容,尽管对于这个简单的示例 `*ptr = 5` 也可以工作。
    ptr.write(5);
    let x = Box::from_raw_in(ptr, System);
}
Run
1.4.0 · source

pub fn into_raw(b: Self) -> *mut T

消耗 Box,并返回一个包装的裸指针。

指针将正确对齐且不为空。

调用此函数后,调用者将负责先前由 Box 管理的内存。 特别地,考虑到 Box 使用的 内存布局,调用者应正确销毁 T 并释放内存。 最简单的方法是使用 Box::from_raw 函数将裸指针转换回 Box,从而允许 Box 析构函数执行清理。

Note: 这是一个关联函数,这意味着您必须将其称为 Box::into_raw(b) 而不是 b.into_raw()。 这样就不会与内部类型的方法发生冲突。

Examples

使用 Box::from_raw 将裸指针转换回 Box 以进行自动清理:

let x = Box::new(String::from("Hello"));
let ptr = Box::into_raw(x);
let x = unsafe { Box::from_raw(ptr) };
Run

通过显式运行析构函数并释放内存来进行手动清理:

use std::alloc::{dealloc, Layout};
use std::ptr;

let x = Box::new(String::from("Hello"));
let p = Box::into_raw(x);
unsafe {
    ptr::drop_in_place(p);
    dealloc(p as *mut u8, Layout::new::<String>());
}
Run
source

pub fn into_raw_with_allocator(b: Self) -> (*mut T, A)

🔬This is a nightly-only experimental API. (allocator_api #32838)

消耗 Box,返回包装的裸指针和分配器。

指针将正确对齐且不为空。

调用此函数后,调用者将负责先前由 Box 管理的内存。 特别地,考虑到 Box 使用的 内存布局,调用者应正确销毁 T 并释放内存。 最简单的方法是使用 Box::from_raw_in 函数将裸指针转换回 Box,从而允许 Box 析构函数执行清理。

Note: 这是一个关联函数,这意味着您必须将其称为 Box::into_raw_with_allocator(b) 而不是 b.into_raw_with_allocator()。 这样就不会与内部类型的方法发生冲突。

Examples

使用 Box::from_raw_in 将裸指针转换回 Box 以进行自动清理:

#![feature(allocator_api)]

use std::alloc::System;

let x = Box::new_in(String::from("Hello"), System);
let (ptr, alloc) = Box::into_raw_with_allocator(x);
let x = unsafe { Box::from_raw_in(ptr, alloc) };
Run

通过显式运行析构函数并释放内存来进行手动清理:

#![feature(allocator_api)]

use std::alloc::{Allocator, Layout, System};
use std::ptr::{self, NonNull};

let x = Box::new_in(String::from("Hello"), System);
let (ptr, alloc) = Box::into_raw_with_allocator(x);
unsafe {
    ptr::drop_in_place(ptr);
    let non_null = NonNull::new_unchecked(ptr);
    alloc.deallocate(non_null.cast(), Layout::new::<String>());
}
Run
const: unstable · source

pub fn allocator(b: &Self) -> &A

🔬This is a nightly-only experimental API. (allocator_api #32838)

返回底层分配器的引用。

Note: 这是一个关联函数,这意味着您必须将其称为 Box::allocator(&b) 而不是 b.allocator()。 这样就不会与内部类型的方法发生冲突。

1.26.0 · source

pub fn leak<'a>(b: Self) -> &'a mut Twhere A: 'a,

消耗并泄漏 Box,返回一个可变引用,&'a mut T。 请注意,类型 T 必须超过所选的生命周期 'a。 如果类型仅具有静态引用,或者根本没有静态引用,则可以将其选择为 'static

该函数主要用于在程序的剩余生命期内保留的数据。 丢弃返回的引用将导致内存泄漏。 如果这是不可接受的,则应首先将引用与 Box::from_raw 函数包装在一起,生成 Box

这个 Box 可以被丢弃,这将正确销毁 T 并释放分配的内存。

Note: 这是一个关联函数,这意味着您必须将其称为 Box::leak(b) 而不是 b.leak()。 这样就不会与内部类型的方法发生冲突。

Examples

简单用法:

let x = Box::new(41);
let static_ref: &'static mut usize = Box::leak(x);
*static_ref += 1;
assert_eq!(*static_ref, 42);
Run

未定义大小的数据:

let x = vec![1, 2, 3].into_boxed_slice();
let static_ref = Box::leak(x);
static_ref[0] = 4;
assert_eq!(*static_ref, [4, 2, 3]);
Run
1.63.0 (const: unstable) · source

pub fn into_pin(boxed: Self) -> Pin<Self>where A: 'static,

Box<T> 转换为 Pin<Box<T>>。如果 T 没有实现 Unpin,那么 *boxed 将被固定在内存中并且无法移动。

这种转换不会在堆上分配,而是就地进行。

也可以通过 From 获得。

使用 Box::into_pin(Box::new(x)) 构造和固定 Box 也可以使用 Box::pin(x) 更简洁地编写。

如果您已经拥有 Box<T>,或者您正在以与 Box::new 不同的方式构建 (pinned) Box,则此 into_pin 方法很有用。

Notes

不建议 crates 添加 From<Box<T>> for Pin<T> 之类的 impl,因为它会在调用 Pin::from 时引入歧义。 下面显示了这样一个糟糕的 impl 的演示。

struct Foo; // 在此 crate 中定义的类型。
impl From<Box<()>> for Pin<Foo> {
    fn from(_: Box<()>) -> Pin<Foo> {
        Pin::new(Foo)
    }
}

let foo = Box::new(());
let bar = Pin::from(foo);
Run
source§

impl<A: Allocator> Box<dyn Any, A>

source

pub fn downcast<T: Any>(self) -> Result<Box<T, A>, Self>

尝试将 box 转换为具体类型。

Examples
use std::any::Any;

fn print_if_string(value: Box<dyn Any>) {
    if let Ok(string) = value.downcast::<String>() {
        println!("String ({}): {}", string.len(), string);
    }
}

let my_string = "Hello World".to_string();
print_if_string(Box::new(my_string));
print_if_string(Box::new(0i8));
Run
source

pub unsafe fn downcast_unchecked<T: Any>(self) -> Box<T, A>

🔬This is a nightly-only experimental API. (downcast_unchecked #90850)

将 box 向下转换为具体类型。

有关安全的替代方案,请参见 downcast

Examples
#![feature(downcast_unchecked)]

use std::any::Any;

let x: Box<dyn Any> = Box::new(1_usize);

unsafe {
    assert_eq!(*x.downcast_unchecked::<usize>(), 1);
}
Run
Safety

包含的值必须是 T 类型。 使用不正确的类型调用此方法是 未定义的行为

source§

impl<A: Allocator> Box<dyn Any + Send, A>

source

pub fn downcast<T: Any>(self) -> Result<Box<T, A>, Self>

尝试将 box 转换为具体类型。

Examples
use std::any::Any;

fn print_if_string(value: Box<dyn Any + Send>) {
    if let Ok(string) = value.downcast::<String>() {
        println!("String ({}): {}", string.len(), string);
    }
}

let my_string = "Hello World".to_string();
print_if_string(Box::new(my_string));
print_if_string(Box::new(0i8));
Run
source

pub unsafe fn downcast_unchecked<T: Any>(self) -> Box<T, A>

🔬This is a nightly-only experimental API. (downcast_unchecked #90850)

将 box 向下转换为具体类型。

有关安全的替代方案,请参见 downcast

Examples
#![feature(downcast_unchecked)]

use std::any::Any;

let x: Box<dyn Any + Send> = Box::new(1_usize);

unsafe {
    assert_eq!(*x.downcast_unchecked::<usize>(), 1);
}
Run
Safety

包含的值必须是 T 类型。 使用不正确的类型调用此方法是 未定义的行为

source§

impl<A: Allocator> Box<dyn Any + Send + Sync, A>

1.51.0 · source

pub fn downcast<T: Any>(self) -> Result<Box<T, A>, Self>

尝试将 box 转换为具体类型。

Examples
use std::any::Any;

fn print_if_string(value: Box<dyn Any + Send + Sync>) {
    if let Ok(string) = value.downcast::<String>() {
        println!("String ({}): {}", string.len(), string);
    }
}

let my_string = "Hello World".to_string();
print_if_string(Box::new(my_string));
print_if_string(Box::new(0i8));
Run
source

pub unsafe fn downcast_unchecked<T: Any>(self) -> Box<T, A>

🔬This is a nightly-only experimental API. (downcast_unchecked #90850)

将 box 向下转换为具体类型。

有关安全的替代方案,请参见 downcast

Examples
#![feature(downcast_unchecked)]

use std::any::Any;

let x: Box<dyn Any + Send + Sync> = Box::new(1_usize);

unsafe {
    assert_eq!(*x.downcast_unchecked::<usize>(), 1);
}
Run
Safety

包含的值必须是 T 类型。 使用不正确的类型调用此方法是 未定义的行为

Trait Implementations§

1.5.0 · source§

impl<T: ?Sized, A: Allocator> AsMut<T> for Box<T, A>

source§

fn as_mut(&mut self) -> &mut T

将此类型转换为 (通常是推断的) 输入类型的错误引用。
1.5.0 · source§

impl<T: ?Sized, A: Allocator> AsRef<T> for Box<T, A>

source§

fn as_ref(&self) -> &T

将此类型转换为 (通常是推断的) 输入类型的共享引用。
source§

impl<S: ?Sized + AsyncIterator + Unpin> AsyncIterator for Box<S>

§

type Item = <S as AsyncIterator>::Item

🔬This is a nightly-only experimental API. (async_iterator #79024)
异步迭代器产生的项的类型。
source§

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_> ) -> Poll<Option<Self::Item>>

🔬This is a nightly-only experimental API. (async_iterator #79024)
尝试提取此异步迭代器的下一个值,如果该值尚不可用,则注册当前任务以进行唤醒,如果异步迭代器耗尽,则返回 NoneRead more
source§

fn size_hint(&self) -> (usize, Option<usize>)

🔬This is a nightly-only experimental API. (async_iterator #79024)
返回异步迭代器剩余长度的界限。 Read more
1.1.0 · source§

impl<T: ?Sized, A: Allocator> Borrow<T> for Box<T, A>

source§

fn borrow(&self) -> &T

从拥有的值中一成不变地借用。 Read more
1.1.0 · source§

impl<T: ?Sized, A: Allocator> BorrowMut<T> for Box<T, A>

source§

fn borrow_mut(&mut self) -> &mut T

从拥有的值中借用。 Read more
1.3.0 · source§

impl<T: Clone, A: Allocator + Clone> Clone for Box<[T], A>

source§

fn clone(&self) -> Self

返回值的副本。 Read more
source§

fn clone_from(&mut self, other: &Self)

source 执行复制分配。 Read more
1.29.0 · source§

impl Clone for Box<CStr>

source§

fn clone(&self) -> Self

返回值的副本。 Read more
source§

fn clone_from(&mut self, source: &Self)

source 执行复制分配。 Read more
source§

impl<T: Clone, A: Allocator + Clone> Clone for Box<T, A>

source§

fn clone(&self) -> Self

返回带有此 box 的 内容的 clone() 的新 box。

Examples
let x = Box::new(5);
let y = x.clone();

// 值是一样的
assert_eq!(x, y);

// 但它们是独一无二的对象
assert_ne!(&*x as *const i32, &*y as *const i32);
Run
source§

fn clone_from(&mut self, source: &Self)

source 的内容复制到 self,而不创建新的分配。

Examples
let x = Box::new(5);
let mut y = Box::new(10);
let yp: *const i32 = &*y;

y.clone_from(&x);

// 值是一样的
assert_eq!(x, y);

// 并且没有发生分配
assert_eq!(yp, &*y);
Run
1.3.0 · source§

impl Clone for Box<str>

source§

fn clone(&self) -> Self

返回值的副本。 Read more
source§

fn clone_from(&mut self, source: &Self)

source 执行复制分配。 Read more
source§

impl<T: Debug + ?Sized, A: Allocator> Debug for Box<T, A>

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

使用给定的格式化程序格式化该值。 Read more
source§

impl<T> Default for Box<[T]>

source§

fn default() -> Self

返回类型的 “默认值”。 Read more
1.17.0 · source§

impl Default for Box<CStr>

source§

fn default() -> Box<CStr>

返回类型的 “默认值”。 Read more
source§

impl<T: Default> Default for Box<T>

source§

fn default() -> Self

创建一个 Box<T>,其 T 值为 Default

1.17.0 · source§

impl Default for Box<str>

source§

fn default() -> Self

返回类型的 “默认值”。 Read more
source§

impl<T: ?Sized, A: Allocator> Deref for Box<T, A>

§

type Target = T

解引用后的结果类型。
source§

fn deref(&self) -> &T

解引用值。
source§

impl<T: ?Sized, A: Allocator> DerefMut for Box<T, A>

source§

fn deref_mut(&mut self) -> &mut T

可变地解引用该值。
source§

impl<T: Display + ?Sized, A: Allocator> Display for Box<T, A>

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

使用给定的格式化程序格式化该值。 Read more
source§

impl<I: DoubleEndedIterator + ?Sized, A: Allocator> DoubleEndedIterator for Box<I, A>

source§

fn next_back(&mut self) -> Option<I::Item>

从迭代器的末尾删除并返回一个元素。 Read more
source§

fn nth_back(&mut self, n: usize) -> Option<I::Item>

从迭代器的末尾返回第 n 个元素。 Read more
source§

fn advance_back_by(&mut self, n: usize) -> Result<(), NonZeroUsize>

🔬This is a nightly-only experimental API. (iter_advance_by #77404)
通过 n 元素从后向前推进迭代器。 Read more
1.27.0 · source§

fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> Rwhere Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Output = B>,

这是 Iterator::try_fold() 的反向版本:它从迭代器的后面开始接收元素。 Read more
1.27.0 · source§

fn rfold<B, F>(self, init: B, f: F) -> Bwhere Self: Sized, F: FnMut(B, Self::Item) -> B,

一种迭代器方法,从后面开始,将迭代器的元素减少为单个最终值。 Read more
1.27.0 · source§

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>where Self: Sized, P: FnMut(&Self::Item) -> bool,

从后面搜索满足谓词的迭代器的元素。 Read more
source§

impl<T: ?Sized, A: Allocator> Drop for Box<T, A>

source§

fn drop(&mut self)

执行此类型的析构函数。 Read more
1.8.0 · source§

impl<T: Error> Error for Box<T>

source§

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()
source§

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
source§

fn source(&self) -> Option<&(dyn Error + 'static)>

此错误的下级来源 (如果有)。 Read more
source§

fn provide<'a>(&'a self, demand: &mut Demand<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access #99301)
提供对用于错误报告的上下文的基于类型的访问。 Read more
source§

impl<I: ExactSizeIterator + ?Sized, A: Allocator> ExactSizeIterator for Box<I, A>

source§

fn len(&self) -> usize

返回迭代器的确切剩余长度。 Read more
source§

fn is_empty(&self) -> bool

🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
如果迭代器为空,则返回 trueRead more
1.45.0 · source§

impl Extend<Box<str, Global>> for String

source§

fn extend<I: IntoIterator<Item = Box<str>>>(&mut self, iter: I)

使用迭代器的内容扩展集合。 Read more
source§

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one #72631)
用一个元素扩展一个集合。
source§

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one #72631)
在集合中为给定数量的附加元素保留容量。 Read more
1.35.0 · source§

impl<Args: Tuple, F: Fn<Args> + ?Sized, A: Allocator> Fn<Args> for Box<F, A>

source§

extern "rust-call" fn call(&self, args: Args) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits #29625)
执行调用操作。
1.35.0 · source§

impl<Args: Tuple, F: FnMut<Args> + ?Sized, A: Allocator> FnMut<Args> for Box<F, A>

source§

extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits #29625)
执行调用操作。
1.35.0 · source§

impl<Args: Tuple, F: FnOnce<Args> + ?Sized, A: Allocator> FnOnce<Args> for Box<F, A>

§

type Output = <F as FnOnce<Args>>::Output

使用调用运算符后的返回类型。
source§

extern "rust-call" fn call_once(self, args: Args) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits #29625)
执行调用操作。
1.17.0 · source§

impl<T: Clone> From<&[T]> for Box<[T]>

source§

fn from(slice: &[T]) -> Box<[T]>

&[T] 转换为 Box<[T]>

此转换在堆上分配并执行 slice 及其内容的副本。

Examples
// 创建 &[u8] which 将用于创建 Box<[u8]>
let slice: &[u8] = &[104, 101, 108, 108, 111];
let boxed_slice: Box<[u8]> = Box::from(slice);

println!("{boxed_slice:?}");
Run
1.17.0 · source§

impl From<&CStr> for Box<CStr>

source§

fn from(s: &CStr) -> Box<CStr>

通过将内容复制到新分配的 Box 中,将 &CStr 转换为 Box<CStr>

1.6.0 · source§

impl From<&str> for Box<dyn Error>

source§

fn from(err: &str) -> Box<dyn Error>

str 转换为 dyn Error 的 box。

Examples
use std::error::Error;
use std::mem;

let a_str_error = "a str error";
let a_boxed_error = Box::<dyn Error>::from(a_str_error);
assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))
Run
source§

impl<'a> From<&str> for Box<dyn Error + Send + Sync + 'a>

source§

fn from(err: &str) -> Box<dyn Error + Send + Sync + 'a>

str 转换为 Dyn Error + Send + Sync 的 box。

Examples
use std::error::Error;
use std::mem;

let a_str_error = "a str error";
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_str_error);
assert!(
    mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))
Run
1.17.0 · source§

impl From<&str> for Box<str>

source§

fn from(s: &str) -> Box<str>

&str 转换为 Box<str>

此转换在堆上分配并执行 s 的副本。

Examples
let boxed: Box<str> = Box::from("hello");
println!("{boxed}");
Run
1.45.0 · source§

impl<T, const N: usize> From<[T; N]> for Box<[T]>

source§

fn from(array: [T; N]) -> Box<[T]>

[T; N] 转换为 Box<[T]>

此转换将数组移动到新的堆分配的内存中。

Examples
let boxed: Box<[u8]> = Box::from([4, 2]);
println!("{boxed:?}");
Run
1.18.0 · source§

impl<T, A: Allocator> From<Box<[T], A>> for Vec<T, A>

source§

fn from(s: Box<[T], A>) -> Self

通过转移现有堆分配的所有权,将 boxed 切片转换为 vector。

Examples
let b: Box<[i32]> = vec![1, 2, 3].into_boxed_slice();
assert_eq!(Vec::from(b), vec![1, 2, 3]);
Run
1.18.0 · source§

impl From<Box<CStr, Global>> for CString

source§

fn from(s: Box<CStr>) -> CString

Box<CStr> 转换为 CString,无需复制或分配。

1.33.0 · source§

impl<T: ?Sized, A> From<Box<T, A>> for Pin<Box<T, A>>where A: 'static + Allocator,

source§

fn from(boxed: Box<T, A>) -> Self

Box<T> 转换为 Pin<Box<T>>。如果 T 没有实现 Unpin,那么 *boxed 将被固定在内存中并且无法移动。

这种转换不会在堆上分配,而是就地进行。

这也可以通过 Box::into_pin 获得。

使用 <Pin<Box<T>>>::from(Box::new(x)) 构造和固定 Box 也可以使用 Box::pin(x) 更简洁地编写。

如果您已经拥有 Box<T>,或者您正在以与 Box::new 不同的方式构建 (pinned) Box,则此 From 实现很有用。

1.21.0 · source§

impl<T: ?Sized> From<Box<T, Global>> for Arc<T>

source§

fn from(v: Box<T>) -> Arc<T>

将 boxed 对象移动到新的引用计数分配。

Example
let unique: Box<str> = Box::from("eggplant");
let shared: Arc<str> = Arc::from(unique);
assert_eq!("eggplant", &shared[..]);
Run
1.21.0 · source§

impl<T: ?Sized> From<Box<T, Global>> for Rc<T>

source§

fn from(v: Box<T>) -> Rc<T>

将 boxed 对象移动到引用计数的新分配。

Example
let original: Box<i32> = Box::new(1);
let shared: Rc<i32> = Rc::from(original);
assert_eq!(1, *shared);
Run
1.19.0 · source§

impl<A: Allocator> From<Box<str, A>> for Box<[u8], A>

source§

fn from(s: Box<str, A>) -> Self

Box<str> 转换为 Box<[u8]>

这种转换不会在堆上分配,而是就地进行。

Examples
// 创建一个 Box<str>,该 Box<str> 将用于创建 Box<[u8]>
let boxed: Box<str> = Box::from("hello");
let boxed_str: Box<[u8]> = Box::from(boxed);

// 创建 &[u8] which 将用于创建 Box<[u8]>
let slice: &[u8] = &[104, 101, 108, 108, 111];
let boxed_slice = Box::from(slice);

assert_eq!(boxed_slice, boxed_str);
Run
1.18.0 · source§

impl From<Box<str, Global>> for String

source§

fn from(s: Box<str>) -> String

将给定的 boxed str 切片转换为 String。 值得注意的是,str 切片是拥有的。

Examples

基本用法:

let s1: String = String::from("hello world");
let s2: Box<str> = s1.into_boxed_str();
let s3: String = String::from(s2);

assert_eq!("hello world", s3)
Run
1.20.0 · source§

impl From<CString> for Box<CStr>

source§

fn from(s: CString) -> Box<CStr>

CString 转换为 Box<CStr>,无需复制或分配。

1.45.0 · source§

impl<T: Clone> From<Cow<'_, [T]>> for Box<[T]>

source§

fn from(cow: Cow<'_, [T]>) -> Box<[T]>

Cow<'_, [T]> 转换为 Box<[T]>

cowCow::Borrowed 变体时,此转换在堆上分配并复制底层切片。 否则,它将尝试重用拥有所有权的 Vec 的分配。

1.45.0 · source§

impl From<Cow<'_, CStr>> for Box<CStr>

source§

fn from(cow: Cow<'_, CStr>) -> Box<CStr>

通过复制借用的内容将 Cow<'a, CStr> 转换为 Box<CStr>

1.45.0 · source§

impl From<Cow<'_, str>> for Box<str>

source§

fn from(cow: Cow<'_, str>) -> Box<str>

Cow<'_, str> 转换为 Box<str>

cowCow::Borrowed 变体时,此转换在堆上分配并复制底层 str。 否则,它将尝试重用拥有所有权的 String 的分配。

Examples
use std::borrow::Cow;

let unboxed = Cow::Borrowed("hello");
let boxed: Box<str> = Box::from(unboxed);
println!("{boxed}");
Run
let unboxed = Cow::Owned("hello".to_string());
let boxed: Box<str> = Box::from(unboxed);
println!("{boxed}");
Run
1.22.0 · source§

impl<'a> From<Cow<'a, str>> for Box<dyn Error>

source§

fn from(err: Cow<'a, str>) -> Box<dyn Error>

Cow 转换为 dyn Error 的 box。

Examples
use std::error::Error;
use std::mem;
use std::borrow::Cow;

let a_cow_str_error = Cow::from("a str error");
let a_boxed_error = Box::<dyn Error>::from(a_cow_str_error);
assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))
Run
1.22.0 · source§

impl<'a, 'b> From<Cow<'b, str>> for Box<dyn Error + Send + Sync + 'a>

source§

fn from(err: Cow<'b, str>) -> Box<dyn Error + Send + Sync + 'a>

Cow 转换为 Dyn Error + Send + Sync 的 box。

Examples
use std::error::Error;
use std::mem;
use std::borrow::Cow;

let a_cow_str_error = Cow::from("a str error");
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_cow_str_error);
assert!(
    mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))
Run
source§

impl<'a, E: Error + 'a> From<E> for Box<dyn Error + 'a>

source§

fn from(err: E) -> Box<dyn Error + 'a>

Error 的类型转换为 dyn Error 的 box。

Examples
use std::error::Error;
use std::fmt;
use std::mem;

#[derive(Debug)]
struct AnError;

impl fmt::Display for AnError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "An error")
    }
}

impl Error for AnError {}

let an_error = AnError;
assert!(0 == mem::size_of_val(&an_error));
let a_boxed_error = Box::<dyn Error>::from(an_error);
assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))
Run
source§

impl<'a, E: Error + Send + Sync + 'a> From<E> for Box<dyn Error + Send + Sync + 'a>

source§

fn from(err: E) -> Box<dyn Error + Send + Sync + 'a>

Error + Send + Sync 的类型转换为 Dyn Error + Send + Sync 的 box。

Examples
use std::error::Error;
use std::fmt;
use std::mem;

#[derive(Debug)]
struct AnError;

impl fmt::Display for AnError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "An error")
    }
}

impl Error for AnError {}

unsafe impl Send for AnError {}

unsafe impl Sync for AnError {}

let an_error = AnError;
assert!(0 == mem::size_of_val(&an_error));
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(an_error);
assert!(
    mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))
Run
1.6.0 · source§

impl From<String> for Box<dyn Error>

source§

fn from(str_err: String) -> Box<dyn Error>

String 转换为 dyn Error 的 box。

Examples
use std::error::Error;
use std::mem;

let a_string_error = "a string error".to_string();
let a_boxed_error = Box::<dyn Error>::from(a_string_error);
assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))
Run
source§

impl From<String> for Box<dyn Error + Send + Sync>

source§

fn from(err: String) -> Box<dyn Error + Send + Sync>

String 转换为 Dyn Error + Send + Sync 的 box。

Examples
use std::error::Error;
use std::mem;

let a_string_error = "a string error".to_string();
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_string_error);
assert!(
    mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))
Run
1.20.0 · source§

impl From<String> for Box<str>

source§

fn from(s: String) -> Box<str>

将给定的 String 转换为拥有所有权的 boxed str 切片。

Examples

基本用法:

let s1: String = String::from("hello world");
let s2: Box<str> = Box::from(s1);
let s3: String = String::from(s2);

assert_eq!("hello world", s3)
Run
1.6.0 · source§

impl<T> From<T> for Box<T>

source§

fn from(t: T) -> Self

T 转换为 Box<T>

转换在堆上分配,并将 t 从栈移到堆中。

Examples
let x = 5;
let boxed = Box::new(5);

assert_eq!(Box::from(x), boxed);
Run
1.20.0 · source§

impl<T, A: Allocator> From<Vec<T, A>> for Box<[T], A>

source§

fn from(v: Vec<T, A>) -> Self

将 vector 转换为 boxed。

如果 v 有多余的容量,它的项将被移动到新分配的缓冲区中,缓冲区的容量恰好是正确的。

Examples
assert_eq!(Box::from(vec![1, 2, 3]), vec![1, 2, 3].into_boxed_slice());
Run

任何多余的容量都将被删除:

let mut vec = Vec::with_capacity(10);
vec.extend([1, 2, 3]);

assert_eq!(Box::from(vec), vec![1, 2, 3].into_boxed_slice());
Run
1.45.0 · source§

impl FromIterator<Box<str, Global>> for String

source§

fn from_iter<I: IntoIterator<Item = Box<str>>>(iter: I) -> String

从迭代器创建一个值。 Read more
1.32.0 · source§

impl<I> FromIterator<I> for Box<[I]>

source§

fn from_iter<T: IntoIterator<Item = I>>(iter: T) -> Self

从迭代器创建一个值。 Read more
1.36.0 · source§

impl<F: ?Sized + Future + Unpin, A> Future for Box<F, A>where A: 'static + Allocator,

§

type Output = <F as Future>::Output

完成时产生的值类型。
source§

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

尝试将 future 解析为最终值,如果该值尚不可用,请注册当前任务以进行唤醒。 Read more
source§

impl<G: ?Sized + Generator<R> + Unpin, R, A> Generator<R> for Box<G, A>where A: 'static + Allocator,

§

type Yield = <G as Generator<R>>::Yield

🔬This is a nightly-only experimental API. (generator_trait #43122)
此生成器产生的值的类型。 Read more
§

type Return = <G as Generator<R>>::Return

🔬This is a nightly-only experimental API. (generator_trait #43122)
此生成器返回的值的类型。 Read more
source§

fn resume( self: Pin<&mut Self>, arg: R ) -> GeneratorState<Self::Yield, Self::Return>

🔬This is a nightly-only experimental API. (generator_trait #43122)
恢复此生成器的执行。 Read more
source§

impl<G: ?Sized + Generator<R>, R, A> Generator<R> for Pin<Box<G, A>>where A: 'static + Allocator,

§

type Yield = <G as Generator<R>>::Yield

🔬This is a nightly-only experimental API. (generator_trait #43122)
此生成器产生的值的类型。 Read more
§

type Return = <G as Generator<R>>::Return

🔬This is a nightly-only experimental API. (generator_trait #43122)
此生成器返回的值的类型。 Read more
source§

fn resume( self: Pin<&mut Self>, arg: R ) -> GeneratorState<Self::Yield, Self::Return>

🔬This is a nightly-only experimental API. (generator_trait #43122)
恢复此生成器的执行。 Read more
source§

impl<T: ?Sized + Hash, A: Allocator> Hash for Box<T, A>

source§

fn hash<H: Hasher>(&self, state: &mut H)

将该值输入给定的 HasherRead more
1.3.0 · source§

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

将这种类型的切片送入给定的 Hasher 中。 Read more
1.22.0 · source§

impl<T: ?Sized + Hasher, A: Allocator> Hasher for Box<T, A>

source§

fn finish(&self) -> u64

返回到目前为止写入的值的哈希值。 Read more
source§

fn write(&mut self, bytes: &[u8])

将一些数据写入此 HasherRead more
source§

fn write_u8(&mut self, i: u8)

将单个 u8 写入此哈希器。
source§

fn write_u16(&mut self, i: u16)

将单个 u16 写入此哈希器。
source§

fn write_u32(&mut self, i: u32)

将单个 u32 写入此哈希器。
source§

fn write_u64(&mut self, i: u64)

将单个 u64 写入此哈希器。
source§

fn write_u128(&mut self, i: u128)

将单个 u128 写入此哈希器。
source§

fn write_usize(&mut self, i: usize)

将单个 usize 写入此哈希器。
source§

fn write_i8(&mut self, i: i8)

将单个 i8 写入此哈希器。
source§

fn write_i16(&mut self, i: i16)

将单个 i16 写入此哈希器。
source§

fn write_i32(&mut self, i: i32)

将单个 i32 写入此哈希器。
source§

fn write_i64(&mut self, i: i64)

将单个 i64 写入此哈希器。
source§

fn write_i128(&mut self, i: i128)

将单个 i128 写入此哈希器。
source§

fn write_isize(&mut self, i: isize)

将单个 isize 写入此哈希器。
source§

fn write_length_prefix(&mut self, len: usize)

🔬This is a nightly-only experimental API. (hasher_prefixfree_extras #96762)
将长度前缀写入此哈希器,作为无前缀的一部分。 Read more
source§

fn write_str(&mut self, s: &str)

🔬This is a nightly-only experimental API. (hasher_prefixfree_extras #96762)
将单个 str 写入此哈希器。 Read more
source§

impl<I: Iterator + ?Sized, A: Allocator> Iterator for Box<I, A>

§

type Item = <I as Iterator>::Item

被迭代的元素的类型。
source§

fn next(&mut self) -> Option<I::Item>

推进迭代器并返回下一个值。 Read more
source§

fn size_hint(&self) -> (usize, Option<usize>)

返回迭代器剩余长度的界限。 Read more
source§

fn nth(&mut self, n: usize) -> Option<I::Item>

返回迭代器的第 n 个元素。 Read more
source§

fn last(self) -> Option<I::Item>

消耗迭代器,返回最后一个元素。 Read more
source§

fn next_chunk<const N: usize>( &mut self ) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where Self: Sized,

🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
推进迭代器并返回包含下一个 N 值的数组。 Read more
source§

fn count(self) -> usizewhere Self: Sized,

消耗迭代器,计算迭代次数并返回它。 Read more
source§

fn advance_by(&mut self, n: usize) -> Result<(), NonZeroUsize>

🔬This is a nightly-only experimental API. (iter_advance_by #77404)
通过 n 元素使迭代器前进。 Read more
1.28.0 · source§

fn step_by(self, step: usize) -> StepBy<Self>where Self: Sized,

创建一个从同一点开始的迭代器,但在每次迭代时以给定的数量逐步执行。 Read more
source§

fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>where Self: Sized, U: IntoIterator<Item = Self::Item>,

接受两个迭代器,并依次在两个迭代器上创建一个新的迭代器。 Read more
source§

fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where Self: Sized, U: IntoIterator,

将两个迭代器压缩为成对的单个迭代器。 Read more
source§

fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>where Self: Sized, G: FnMut() -> Self::Item,

🔬This is a nightly-only experimental API. (iter_intersperse #79524)
创建一个新的迭代器,该迭代器将 separator 生成的项放在原始迭代器的相邻项之间。 Read more
source§

fn map<B, F>(self, f: F) -> Map<Self, F>where Self: Sized, F: FnMut(Self::Item) -> B,

获取一个闭包并创建一个迭代器,该迭代器在每个元素上调用该闭包。 Read more
1.21.0 · source§

fn for_each<F>(self, f: F)where Self: Sized, F: FnMut(Self::Item),

在迭代器的每个元素上调用一个闭包。 Read more
source§

fn filter<P>(self, predicate: P) -> Filter<Self, P>where Self: Sized, P: FnMut(&Self::Item) -> bool,

创建一个迭代器,该迭代器使用闭包确定是否应产生元素。 Read more
source§

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>where Self: Sized, F: FnMut(Self::Item) -> Option<B>,

创建一个同时过滤和映射的迭代器。 Read more
source§

fn enumerate(self) -> Enumerate<Self>where Self: Sized,

创建一个迭代器,该迭代器给出当前迭代次数以及下一个值。 Read more
source§

fn peekable(self) -> Peekable<Self>where Self: Sized,

创建一个迭代器,它可以使用 peekpeek_mut 方法查看迭代器的下一个元素而不消耗它。有关更多信息,请参见他们的文档。 Read more
source§

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>where Self: Sized, P: FnMut(&Self::Item) -> bool,

创建一个迭代器,该迭代器基于谓词 skip 元素。 Read more
source§

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>where Self: Sized, P: FnMut(&Self::Item) -> bool,

创建一个迭代器,该迭代器根据谓词产生元素。 Read more
1.57.0 · source§

fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>where Self: Sized, P: FnMut(Self::Item) -> Option<B>,

创建一个迭代器,该迭代器均基于谓词和映射生成元素。 Read more
source§

fn skip(self, n: usize) -> Skip<Self>where Self: Sized,

创建一个跳过前 n 个元素的迭代器。 Read more
source§

fn take(self, n: usize) -> Take<Self>where Self: Sized,

创建一个迭代器,它产生第一个 n 元素,如果底层迭代器提前结束,则产生更少的元素。 Read more
source§

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>where Self: Sized, F: FnMut(&mut St, Self::Item) -> Option<B>,

一个迭代器适配器,它与 fold 一样保存内部状态,但与 fold 不同,它生成一个新的迭代器。 Read more
source§

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where Self: Sized, U: IntoIterator, F: FnMut(Self::Item) -> U,

创建一个迭代器,其工作方式类似于 map,但它会将嵌套的结构展平。 Read more
source§

fn fuse(self) -> Fuse<Self>where Self: Sized,

创建一个迭代器,该迭代器在第一个 None 之后结束。 Read more
source§

fn inspect<F>(self, f: F) -> Inspect<Self, F>where Self: Sized, F: FnMut(&Self::Item),

对迭代器的每个元素执行某些操作,将值传递给它。 Read more
source§

fn by_ref(&mut self) -> &mut Selfwhere Self: Sized,

借用一个迭代器,而不是使用它。 Read more
source§

fn collect<B>(self) -> Bwhere B: FromIterator<Self::Item>, Self: Sized,

将迭代器转换为集合。 Read more
source§

fn collect_into<E>(self, collection: &mut E) -> &mut Ewhere E: Extend<Self::Item>, Self: Sized,

🔬This is a nightly-only experimental API. (iter_collect_into #94780)
将迭代器中的所有项收集到一个集合中。 Read more
source§

fn partition<B, F>(self, f: F) -> (B, B)where Self: Sized, B: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool,

消耗一个迭代器,从中创建两个集合。 Read more
source§

fn is_partitioned<P>(self, predicate: P) -> boolwhere Self: Sized, P: FnMut(Self::Item) -> bool,

🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
检查此迭代器的元素是否根据给定的谓词进行了分区,以便所有返回 true 的元素都在所有返回 false 的元素之前。 Read more
1.27.0 · source§

fn try_fold<B, F, R>(&mut self, init: B, f: F) -> Rwhere Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Output = B>,

一个迭代器方法,它只要成功返回就应用函数,并产生单个最终值。 Read more
1.27.0 · source§

fn try_for_each<F, R>(&mut self, f: F) -> Rwhere Self: Sized, F: FnMut(Self::Item) -> R, R: Try<Output = ()>,

一个迭代器方法,该方法将一个容易犯错的函数应用于迭代器中的每个项,在第一个错误处停止并返回该错误。 Read more
source§

fn fold<B, F>(self, init: B, f: F) -> Bwhere Self: Sized, F: FnMut(B, Self::Item) -> B,

通过应用操作将每个元素 fold 到一个累加器中,返回最终结果。 Read more
1.51.0 · source§

fn reduce<F>(self, f: F) -> Option<Self::Item>where Self: Sized, F: FnMut(Self::Item, Self::Item) -> Self::Item,

通过重复应用缩减操作,将元素缩减为一个。 Read more
source§

fn try_reduce<F, R>( &mut self, f: F ) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryTypewhere Self: Sized, F: FnMut(Self::Item, Self::Item) -> R, R: Try<Output = Self::Item>, <R as Try>::Residual: Residual<Option<Self::Item>>,

🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
通过重复应用 Reduce 操作,将元素归约为单个元素。 如果闭包返回失败,则失败会立即传播给调用者。 Read more
source§

fn all<F>(&mut self, f: F) -> boolwhere Self: Sized, F: FnMut(Self::Item) -> bool,

测试迭代器的每个元素是否与谓词匹配。 Read more
source§

fn any<F>(&mut self, f: F) -> boolwhere Self: Sized, F: FnMut(Self::Item) -> bool,

测试迭代器的任何元素是否与谓词匹配。 Read more
source§

fn find<P>(&mut self, predicate: P) -> Option<Self::Item>where Self: Sized, P: FnMut(&Self::Item) -> bool,

搜索满足谓词的迭代器的元素。 Read more
1.30.0 · source§

fn find_map<B, F>(&mut self, f: F) -> Option<B>where Self: Sized, F: FnMut(Self::Item) -> Option<B>,

将函数应用于迭代器的元素,并返回第一个非 None 的结果。 Read more
source§

fn try_find<F, R>( &mut self, f: F ) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryTypewhere Self: Sized, F: FnMut(&Self::Item) -> R, R: Try<Output = bool>, <R as Try>::Residual: Residual<Option<Self::Item>>,

🔬This is a nightly-only experimental API. (try_find #63178)
将函数应用于迭代器的元素,并返回第一个为 true 的结果或第一个错误。 Read more
source§

fn position<P>(&mut self, predicate: P) -> Option<usize>where Self: Sized, P: FnMut(Self::Item) -> bool,

在迭代器中搜索元素,并返回其索引。 Read more
1.6.0 · source§

fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>where B: Ord, Self: Sized, F: FnMut(&Self::Item) -> B,

返回给出指定函数最大值的元素。 Read more
1.15.0 · source§

fn max_by<F>(self, compare: F) -> Option<Self::Item>where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,

返回给出相对于指定比较函数的最大值的元素。 Read more
1.6.0 · source§

fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>where B: Ord, Self: Sized, F: FnMut(&Self::Item) -> B,

返回给出指定函数中最小值的元素。 Read more
1.15.0 · source§

fn min_by<F>(self, compare: F) -> Option<Self::Item>where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,

返回给出相对于指定比较函数的最小值的元素。 Read more
source§

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)where FromA: Default + Extend<A>, FromB: Default + Extend<B>, Self: Sized + Iterator<Item = (A, B)>,

将成对的迭代器转换为一对容器。 Read more
1.36.0 · source§

fn copied<'a, T>(self) -> Copied<Self>where T: 'a + Copy, Self: Sized + Iterator<Item = &'a T>,

创建一个迭代器,该迭代器将复制其所有元素。 Read more
source§

fn cloned<'a, T>(self) -> Cloned<Self>where T: 'a + Clone, Self: Sized + Iterator<Item = &'a T>,

创建一个迭代器,该迭代器将克隆所有元素。 Read more
source§

fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>where Self: Sized,

🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
一次返回迭代器的 N 个元素的迭代器。 Read more
1.11.0 · source§

fn sum<S>(self) -> Swhere Self: Sized, S: Sum<Self::Item>,

对迭代器的元素求和。 Read more
1.11.0 · source§

fn product<P>(self) -> Pwhere Self: Sized, P: Product<Self::Item>,

遍历整个迭代器,将所有元素相乘 Read more
source§

fn cmp_by<I, F>(self, other: I, cmp: F) -> Orderingwhere Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

🔬This is a nightly-only experimental API. (iter_order_by #64295)
字典顺序 根据指定的比较函数将这个 Iterator 的元素与另一个 Iterator 的元素进行比较。 Read more
1.5.0 · source§

fn partial_cmp<I>(self, other: I) -> Option<Ordering>where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Lexicographically 将此 IteratorPartialOrd 元素与另一个 PartialOrd 的元素进行比较。 比较的工作方式类似于短路评估,返回结果而不比较其余元素。 一旦可以确定订单,评估就会停止并返回结果。 Read more
source§

fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

🔬This is a nightly-only experimental API. (iter_order_by #64295)
字典顺序 根据指定的比较函数将这个 Iterator 的元素与另一个 Iterator 的元素进行比较。 Read more
1.5.0 · source§

fn eq<I>(self, other: I) -> boolwhere I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>, Self: Sized,

确定此 Iterator 的元素是否与另一个元素相同。 Read more
source§

fn eq_by<I, F>(self, other: I, eq: F) -> boolwhere Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

🔬This is a nightly-only experimental API. (iter_order_by #64295)
关于指定的相等函数,确定 Iterator 的元素是否与另一个元素相等。 Read more
1.5.0 · source§

fn ne<I>(self, other: I) -> boolwhere I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>, Self: Sized,

确定此 Iterator 的元素是否不等于另一个的元素。 Read more
1.5.0 · source§

fn lt<I>(self, other: I) -> boolwhere I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

确定此 Iterator 的元素是否比另一个元素少 按字典顺序Read more
1.5.0 · source§

fn le<I>(self, other: I) -> boolwhere I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

确定此 Iterator 的元素是否 按字典顺序 小于或等于另一个元素。 Read more
1.5.0 · source§

fn gt<I>(self, other: I) -> boolwhere I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

确定此 Iterator 的元素是否大于另一个元素的 按字典顺序Read more
1.5.0 · source§

fn ge<I>(self, other: I) -> boolwhere I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

确定此 Iterator 的元素是否 按字典顺序 大于或等于另一个元素。 Read more
source§

fn is_sorted_by<F>(self, compare: F) -> boolwhere Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,

🔬This is a nightly-only experimental API. (is_sorted #53485)
检查此迭代器的元素是否使用给定的比较器函数进行排序。 Read more
source§

fn is_sorted_by_key<F, K>(self, f: F) -> boolwhere Self: Sized, F: FnMut(Self::Item) -> K, K: PartialOrd<K>,

🔬This is a nightly-only experimental API. (is_sorted #53485)
检查此迭代器的元素是否使用给定的键提取函数进行排序。 Read more
source§

impl<T: ?Sized + Ord, A: Allocator> Ord for Box<T, A>

source§

fn cmp(&self, other: &Self) -> Ordering

此方法返回 selfother 之间的 OrderingRead more
1.21.0 · source§

fn max(self, other: Self) -> Selfwhere Self: Sized,

比较并返回两个值中的最大值。 Read more
1.21.0 · source§

fn min(self, other: Self) -> Selfwhere Self: Sized,

比较并返回两个值中的最小值。 Read more
1.50.0 · source§

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

将值限制在某个时间间隔内。 Read more
source§

impl<T: ?Sized + PartialEq, A: Allocator> PartialEq<Box<T, A>> for Box<T, A>

source§

fn eq(&self, other: &Self) -> bool

此方法测试 selfother 值是否相等,并由 == 使用。
source§

fn ne(&self, other: &Self) -> bool

此方法测试 !=。 默认实现几乎总是足够的,并且不应在没有充分理由的情况下被覆盖。
source§

impl<T: ?Sized + PartialOrd, A: Allocator> PartialOrd<Box<T, A>> for Box<T, A>

source§

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

如果存在,则此方法返回 selfother 值之间的顺序。 Read more
source§

fn lt(&self, other: &Self) -> bool

此方法测试的内容少于 (对于 selfother),并且由 < 操作员使用。 Read more
source§

fn le(&self, other: &Self) -> bool

此方法测试小于或等于 (对于 selfother),并且由 <= 运算符使用。 Read more
source§

fn ge(&self, other: &Self) -> bool

此方法测试是否大于或等于 (对于 selfother),并且由 >= 运算符使用。 Read more
source§

fn gt(&self, other: &Self) -> bool

此方法测试大于 (对于 selfother),并且由 > 操作员使用。 Read more
source§

impl<T: ?Sized, A: Allocator> Pointer for Box<T, A>

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

使用给定的格式化程序格式化该值。
1.43.0 · source§

impl<T, const N: usize> TryFrom<Box<[T], Global>> for Box<[T; N]>

source§

fn try_from(boxed_slice: Box<[T]>) -> Result<Self, Self::Error>

尝试将 Box<[T]> 转换为 Box<[T; N]>

转换就地发生,不需要新的内存分配。

Errors

如果 boxed_slice.len() 不等于 N,则返回 Err 变体中的旧 Box<[T]>

§

type Error = Box<[T], Global>

发生转换错误时返回的类型。
1.66.0 · source§

impl<T, const N: usize> TryFrom<Vec<T, Global>> for Box<[T; N]>

source§

fn try_from(vec: Vec<T>) -> Result<Self, Self::Error>

尝试将 Vec<T> 转换为 Box<[T; N]>

Vec::into_boxed_slice 一样,如果 vec.capacity() == N 是就地的,则需要重新分配。

Errors

如果 boxed_slice.len() 不等于 N,则返回 Err 变体中的原始 Vec<T>

Examples

这可以与 vec! 一起用于在堆上创建一个数组:

let state: Box<[f32; 100]> = vec![1.0; 100].try_into().unwrap();
assert_eq!(state.len(), 100);
Run
§

type Error = Vec<T, Global>

发生转换错误时返回的类型。
source§

impl<T: ?Sized + Unsize<U>, U: ?Sized, A: Allocator> CoerceUnsized<Box<U, A>> for Box<T, A>

source§

impl<T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<Box<U, Global>> for Box<T, Global>

source§

impl<T: ?Sized + Eq, A: Allocator> Eq for Box<T, A>

1.26.0 · source§

impl<I: FusedIterator + ?Sized, A: Allocator> FusedIterator for Box<I, A>

1.33.0 · source§

impl<T: ?Sized, A> Unpin for Box<T, A>where A: 'static + Allocator,

Auto Trait Implementations§

§

impl<T: ?Sized, A> RefUnwindSafe for Box<T, A>where A: RefUnwindSafe, T: RefUnwindSafe,

§

impl<T: ?Sized, A> Send for Box<T, A>where A: Send, T: Send,

§

impl<T: ?Sized, A> Sync for Box<T, A>where A: Sync, T: Sync,

§

impl<T: ?Sized, A> UnwindSafe for Box<T, A>where A: UnwindSafe, T: UnwindSafe,

Blanket Implementations§

source§

impl<T> Any for Twhere T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

获取 selfTypeIdRead more
source§

impl<T> Borrow<T> for Twhere T: ?Sized,

source§

fn borrow(&self) -> &T

从拥有的值中一成不变地借用。 Read more
source§

impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

从拥有的值中借用。 Read more
source§

impl<T> From<!> for T

source§

fn from(t: !) -> T

从输入类型转换为此类型。
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

返回未更改的参数。

source§

impl<T, U> Into<U> for Twhere U: From<T>,

source§

fn into(self) -> U

调用 U::from(self)

也就是说,这种转换是 From<T> for U 实现选择执行的任何操作。

source§

impl<F> IntoFuture for Fwhere F: Future,

§

type Output = <F as Future>::Output

future 完成时将产生的输出。
§

type IntoFuture = F

我们要把它变成哪种 future?
source§

fn into_future(self) -> <F as IntoFuture>::IntoFuture

根据一个值创建一个 future。 Read more
source§

impl<I> IntoIterator for Iwhere I: Iterator,

§

type Item = <I as Iterator>::Item

被迭代的元素的类型。
§

type IntoIter = I

我们将其变成哪种迭代器?
const: unstable · source§

fn into_iter(self) -> I

从一个值创建一个迭代器。 Read more
source§

impl<'a, F> Pattern<'a> for Fwhere F: FnMut(char) -> bool,

§

type Searcher = CharPredicateSearcher<'a, F>

🔬This is a nightly-only experimental API. (pattern #27721)
此模式的关联搜索者
source§

fn into_searcher(self, haystack: &'a str) -> CharPredicateSearcher<'a, F>

🔬This is a nightly-only experimental API. (pattern #27721)
selfhaystack 构造关联的搜索器以进行搜索。
source§

fn is_contained_in(self, haystack: &'a str) -> bool

🔬This is a nightly-only experimental API. (pattern #27721)
检查模式是否与 haystack 中的任何位置匹配
source§

fn is_prefix_of(self, haystack: &'a str) -> bool

🔬This is a nightly-only experimental API. (pattern #27721)
检查模式是否在 haystack 的前面匹配
source§

fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>

🔬This is a nightly-only experimental API. (pattern #27721)
如果匹配,则从 haystack 的正面删除模式。
source§

fn is_suffix_of(self, haystack: &'a str) -> boolwhere CharPredicateSearcher<'a, F>: ReverseSearcher<'a>,

🔬This is a nightly-only experimental API. (pattern #27721)
检查模式是否与 haystack 的后面匹配
source§

fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str>where CharPredicateSearcher<'a, F>: ReverseSearcher<'a>,

🔬This is a nightly-only experimental API. (pattern #27721)
如果匹配,则从 haystack 的后面删除模式。
source§

impl<E> Provider for Ewhere E: Error + ?Sized,

source§

fn provide<'a>(&'a self, demand: &mut Demand<'a>)

🔬This is a nightly-only experimental API. (provide_any #96024)
数据提供者应实现此方法以提供他们能够通过使用 demand 提供的所有值。 Read more
source§

impl<T> ToOwned for Twhere T: Clone,

§

type Owned = T

获得所有权后的结果类型。
source§

fn to_owned(&self) -> T

从借用的数据创建拥有的数据,通常是通过克隆。 Read more
source§

fn clone_into(&self, target: &mut T)

使用借来的数据来替换拥有的数据,通常是通过克隆。 Read more
source§

impl<T> ToString for Twhere T: Display + ?Sized,

source§

default fn to_string(&self) -> String

将给定值转换为 StringRead more
source§

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

type Error = Infallible

发生转换错误时返回的类型。
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

执行转换。
source§

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

发生转换错误时返回的类型。
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

执行转换。