Struct std::boxed::Box

pub struct Box<T, A = Global>(_, _)
 where
    A: Allocator,
    T: ?Sized;

用于堆分配的指针类型。

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

Implementations

impl<T> Box<T, Global>

pub fn new(x: T) -> Box<T, Global>

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

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

Examples

let five = Box::new(5);

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

🔬 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)

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

🔬 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)

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

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

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

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

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

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

Examples

#![feature(allocator_api)]

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

pub fn try_new_uninit() -> Result<Box<MaybeUninit<T>, Global>, 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);

pub fn try_new_zeroed() -> Result<Box<MaybeUninit<T>, Global>, 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);

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

pub fn new_in(x: T, alloc: A) -> Box<T, A> where
    A: Allocator + Drop, 

🔬 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);

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

🔬 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)?;

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

🔬 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)

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

🔬 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);

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

🔬 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)

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

🔬 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);

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

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

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

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

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

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

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

pub fn into_inner(boxed: Box<T, A>) -> T where
    Box<T, A>: Drop, 

🔬 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);

impl<T> Box<[T], Global>

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

🔬 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])

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

🔬 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])

pub fn try_new_uninit_slice(
    len: usize
) -> Result<Box<[MaybeUninit<T>], Global>, 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]);

pub fn try_new_zeroed_slice(
    len: usize
) -> Result<Box<[MaybeUninit<T>], Global>, 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]);

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

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])

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])

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

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)

pub fn write(boxed: Box<MaybeUninit<T>, A>, 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);
}

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

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])

impl<T> Box<T, Global> where
    T: ?Sized, 

pub unsafe fn from_raw(raw: *mut T) -> Box<T, Global>

从裸指针构造一个 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) };

使用二进制分配器从头开始手动创建 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);
}

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

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

🔬 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) };

使用系统分配器从头开始手动创建 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);
}

pub fn into_raw(b: Box<T, A>) -> *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) };

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

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>());
}

pub fn into_raw_with_allocator(b: Box<T, A>) -> (*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) };

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

#![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>());
}

pub fn allocator(b: &Box<T, A>) -> &A

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

返回底层分配器的引用。

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

pub fn leak<'a>(b: Box<T, A>) -> &'a mut T where
    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);

未定义大小的数据：

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]);

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

🔬 This is a nightly-only experimental API. (box_into_pin #62370)

将 Box<T> 转换为 Pin<Box<T>>

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

也可以通过 From 获得。

impl<A> Box<dyn Any + 'static, A> where
    A: Allocator, 

pub fn downcast<T>(self) -> Result<Box<T, A>, Box<dyn Any + 'static, A>> where
    T: Any, 

尝试将 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));

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

🔬 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);
}

Safety

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

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

pub fn downcast<T>(self) -> Result<Box<T, A>, Box<dyn Any + Send + 'static, A>> where
    T: Any, 

尝试将 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));

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

🔬 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);
}

Safety

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

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

pub fn downcast<T>(
    self
) -> Result<Box<T, A>, Box<dyn Any + Sync + Send + 'static, A>> where
    T: Any, 

尝试将 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));

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

🔬 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);
}

Safety

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

Trait Implementations

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

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

执行转换。

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

pub fn as_ref(&self) -> &T

执行转换。

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

pub fn borrow(&self) -> &T

从拥有的值中一成不变地借用。

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

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

从拥有的值中借用。

impl<B: BufRead + ?Sized> BufRead for Box<B>

fn fill_buf(&mut self) -> Result<&[u8]>

返回内部缓冲区的内容，如果内部缓冲区为空，则使用内部 reader 中的更多数据填充内部缓冲区。

fn consume(&mut self, amt: usize)

告诉此缓冲区 amt 字节已从缓冲区中消耗掉，因此在调用 read 时不再应返回它们。

fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> Result<usize>

将所有字节读入 buf，直到到达定界符 byte 或 EOF。

fn read_line(&mut self, buf: &mut String) -> Result<usize>

读取所有字节，直到到达换行符 (0xA 字节)，然后将它们追加到提供的缓冲区中。

fn has_data_left(&mut self) -> Result<bool>

🔬 This is a nightly-only experimental API. (buf_read_has_data_left #86423)

检查底层 Read 是否有任何数据可供读取。

fn split(self, byte: u8) -> Split<Self> where
    Self: Sized, 

返回对该字节 byte 上的 reader 拆分内容的迭代器。

fn lines(self) -> Lines<Self> where
    Self: Sized, 

返回此 reader 的各行上的迭代器。

impl Clone for Box<str, Global>

pub fn clone(&self) -> Box<str, Global>

返回值的副本。

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

从 source 执行复制分配。

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

pub fn clone(&self) -> Box<T, A>

返回带有此 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);

pub fn clone_from(&mut self, source: &Box<T, A>)

将 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);

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

pub fn clone(&self) -> Box<[T], A>

返回值的副本。

pub fn clone_from(&mut self, other: &Box<[T], A>)

从 source 执行复制分配。

impl Clone for Box<CStr>

fn clone(&self) -> Self

返回值的副本。

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

从 source 执行复制分配。

impl Clone for Box<OsStr>

fn clone(&self) -> Self

返回值的副本。

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

从 source 执行复制分配。

impl Clone for Box<Path>

fn clone(&self) -> Self

返回值的副本。

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

从 source 执行复制分配。

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

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

使用给定的格式化程序格式化该值。

impl Default for Box<str, Global>

pub fn default() -> Box<str, Global>

返回类型的 “默认值”。

impl<T> Default for Box<T, Global> where
    T: Default, 

pub fn default() -> Box<T, Global>

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

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

pub fn default() -> Box<[T], Global>

返回类型的 “默认值”。

impl Default for Box<CStr>

fn default() -> Box<CStr>

返回类型的 “默认值”。

impl Default for Box<OsStr>

fn default() -> Box<OsStr>

返回类型的 “默认值”。

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

type Target = T

解引用后的结果类型。

pub fn deref(&self) -> &T

解引用值。

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

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

可变地解引用该值。

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

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

使用给定的格式化程序格式化该值。

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

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

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

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

从迭代器的末尾返回第 n 个元素。

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

🔬 This is a nightly-only experimental API. (iter_advance_by #77404)

通过 n 元素从后向前推进迭代器。

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

这是 Iterator::try_fold() 的反向版本：它从迭代器的后面开始接收元素。

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

一种迭代器方法，从后面开始，将迭代器的元素减少为单个最终值。

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

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

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

pub fn drop(&mut self)

执行此类型的析构函数。

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

fn description(&self) -> &str

👎 Deprecated since 1.42.0:

use the Display impl or to_string()

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

👎 Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

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

此错误的下级来源 (如果有)。

fn backtrace(&self) -> Option<&Backtrace>

🔬 This is a nightly-only experimental API. (backtrace #53487)

返回发生错误的栈回溯 (如果有)。

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

pub fn len(&self) -> usize

返回迭代器的确切长度。

pub fn is_empty(&self) -> bool

🔬 This is a nightly-only experimental API. (exact_size_is_empty #35428)

如果迭代器为空，则返回 true。

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

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

使用迭代器的内容扩展集合。

fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (extend_one #72631)

用一个元素扩展一个集合。

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one #72631)

在集合中为给定数量的附加元素保留容量。

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

pub extern "rust-call" fn call(
    &self,
    args: Args
) -> <Box<F, A> as FnOnce<Args>>::Output

🔬 This is a nightly-only experimental API. (fn_traits #29625)

执行调用操作。

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

pub extern "rust-call" fn call_mut(
    &mut self,
    args: Args
) -> <Box<F, A> as FnOnce<Args>>::Output

🔬 This is a nightly-only experimental API. (fn_traits #29625)

执行调用操作。

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

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

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

pub extern "rust-call" fn call_once(
    self,
    args: Args
) -> <Box<F, A> as FnOnce<Args>>::Output

🔬 This is a nightly-only experimental API. (fn_traits #29625)

执行调用操作。

impl<'_, T> From<&'_ [T]> for Box<[T], Global> where
    T: Copy, 

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

将 &[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);

impl From<&'_ CStr> for Box<CStr>

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

执行转换。

impl From<&'_ OsStr> for Box<OsStr>

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

执行转换。

impl From<&'_ Path> for Box<Path>

fn from(path: &Path) -> Box<Path>

从引用创建一个 boxed Path。

这将为它分配和克隆 path。

impl<'_> From<&'_ str> for Box<str, Global>

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

将 &str 转换为 Box<str>

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

Examples

let boxed: Box<str> = Box::from("hello");
println!("{}", boxed);

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

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))

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

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))

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

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

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

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

Examples

let boxed: Box<[u8]> = Box::from([4, 2]);
println!("{:?}", boxed);

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

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

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

Examples

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

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

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

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

impl From<Box<OsStr, Global>> for OsString

fn from(boxed: Box<OsStr>) -> OsString

将 Box<OsStr> 转换为 OsString，而无需复制或分配。

impl From<Box<Path, Global>> for PathBuf

fn from(boxed: Box<Path>) -> PathBuf

将 Box<Path> 转换为 PathBuf

此转换不会分配或复制内存。

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

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

将 Box<T> 转换为 Pin<Box<T>>

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

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

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

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

Example

let unique: Box<str> = Box::from("eggplant");
let shared: Arc<str> = Arc::from(unique);
assert_eq!("eggplant", &shared[..]);

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

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

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

Example

let original: Box<i32> = Box::new(1);
let shared: Rc<i32> = Rc::from(original);
assert_eq!(1, *shared);

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

pub fn from(s: Box<str, A>) -> Box<[u8], A>

将 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);

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

pub fn from(s: Box<str, Global>) -> 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)

impl From<CString> for Box<CStr>

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

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

impl<'_, T> From<Cow<'_, [T]>> for Box<[T], Global> where
    T: Copy, 

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

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

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

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

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

执行转换。

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

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

执行转换。

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

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

从写时克隆指针创建一个 boxed Path。

从 Cow::Owned 转换不会克隆或分配。

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

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

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

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

Examples

use std::borrow::Cow;

let unboxed = Cow::Borrowed("hello");
let boxed: Box<str> = Box::from(unboxed);
println!("{}", boxed);

let unboxed = Cow::Owned("hello".to_string());
let boxed: Box<str> = Box::from(unboxed);
println!("{}", boxed);

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

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))

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

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))

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

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))

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

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))

impl From<OsString> for Box<OsStr>

fn from(s: OsString) -> Box<OsStr>

将 OsString 转换为 Box<OsStr>，而无需复制或分配。

impl From<PathBuf> for Box<Path>

fn from(p: PathBuf) -> Box<Path>

将 PathBuf 转换为 Box<Path>

此转换当前不应该分配内存，但是不能在所有平台上或所有 future 版本中都保证此行为。

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

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

将给定的 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)

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

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))

impl From<String> for Box<dyn Error>

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))

impl<T> From<T> for Box<T, Global>

pub fn from(t: T) -> Box<T, Global>

将 T 转换为 Box<T>

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

Examples

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

assert_eq!(Box::from(x), boxed);

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

pub fn from(v: Vec<T, A>) -> Box<[T], A>

将 vector 转换为 boxed。

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

Examples

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

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

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

从迭代器创建一个值。

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

pub fn from_iter<T>(iter: T) -> Box<[I], Global> where
    T: IntoIterator<Item = I>, 

从迭代器创建一个值。

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

type Output = <F as Future>::Output

完成时产生的值类型。

pub fn poll(
    self: Pin<&mut Box<F, A>>,
    cx: &mut Context<'_>
) -> Poll<<Box<F, A> as Future>::Output>

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

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

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

🔬 This is a nightly-only experimental API. (generator_trait #43122)

此生成器产生的值的类型。

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

🔬 This is a nightly-only experimental API. (generator_trait #43122)

此生成器返回的值的类型。

pub fn resume(
    self: Pin<&mut Box<G, A>>,
    arg: R
) -> GeneratorState<<Box<G, A> as Generator<R>>::Yield, <Box<G, A> as Generator<R>>::Return>

🔬 This is a nightly-only experimental API. (generator_trait #43122)

恢复此生成器的执行。

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

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

将该值输入给定的 Hasher。

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

将这种类型的切片送入给定的 Hasher 中。

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

pub fn finish(&self) -> u64

返回到目前为止写入的值的哈希值。

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

将一些数据写入此 Hasher。

pub fn write_u8(&mut self, i: u8)

将单个 u8 写入此哈希器。

pub fn write_u16(&mut self, i: u16)

将单个 u16 写入此哈希器。

pub fn write_u32(&mut self, i: u32)

将单个 u32 写入此哈希器。

pub fn write_u64(&mut self, i: u64)

将单个 u64 写入此哈希器。

pub fn write_u128(&mut self, i: u128)

将单个 u128 写入此哈希器。

pub fn write_usize(&mut self, i: usize)

将单个 usize 写入此哈希器。

pub fn write_i8(&mut self, i: i8)

将单个 i8 写入此哈希器。

pub fn write_i16(&mut self, i: i16)

将单个 i16 写入此哈希器。

pub fn write_i32(&mut self, i: i32)

将单个 i32 写入此哈希器。

pub fn write_i64(&mut self, i: i64)

将单个 i64 写入此哈希器。

pub fn write_i128(&mut self, i: i128)

将单个 i128 写入此哈希器。

pub fn write_isize(&mut self, i: isize)

将单个 isize 写入此哈希器。

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

type Item = <I as Iterator>::Item

被迭代的元素的类型。

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

推进迭代器并返回下一个值。

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

返回迭代器剩余长度的界限。

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

返回迭代器的第 n 个元素。

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

消耗迭代器，返回最后一个元素。

fn count(self) -> usize

消耗迭代器，计算迭代次数并返回它。

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

🔬 This is a nightly-only experimental API. (iter_advance_by #77404)

通过 n 元素使迭代器前进。

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

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

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

接受两个迭代器，并依次在两个迭代器上创建一个新的迭代器。

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

将两个迭代器压缩为成对的单个迭代器。

fn intersperse(self, separator: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

🔬 This is a nightly-only experimental API. (iter_intersperse #79524)

创建一个新的迭代器，该迭代器将 separator 的副本放置在原始迭代器的相邻项之间。

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

🔬 This is a nightly-only experimental API. (iter_intersperse #79524)

创建一个新的迭代器，该迭代器将 separator 生成的项放在原始迭代器的相邻项之间。

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

获取一个闭包并创建一个迭代器，该迭代器在每个元素上调用该闭包。

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

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

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

创建一个迭代器，该迭代器使用闭包确定是否应产生元素。

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

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

fn enumerate(self) -> Enumerate<Self>

创建一个迭代器，该迭代器给出当前迭代次数以及下一个值。

fn peekable(self) -> Peekable<Self>

创建一个迭代器，它可以使用 peek 和 peek_mut 方法查看迭代器的下一个元素而不消耗它。有关更多信息，请参见他们的文档。

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

创建一个迭代器，该迭代器基于谓词 skip 元素。

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

创建一个迭代器，该迭代器根据谓词产生元素。

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

创建一个迭代器，该迭代器均基于谓词和映射生成元素。

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

创建一个跳过前 n 个元素的迭代器。

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

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

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

一个类似于 fold 的迭代器适配器，它保存内部状态并生成一个新的迭代器。

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

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

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoIterator, 

创建一个可简化嵌套结构体的迭代器。

fn fuse(self) -> Fuse<Self>

创建一个迭代器，该迭代器在第一个 None 之后结束。

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

对迭代器的每个元素执行某些操作，将值传递给它。

fn by_ref(&mut self) -> &mut Self

借用一个迭代器，而不是使用它。

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

将迭代器转换为集合。

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

消耗一个迭代器，从中创建两个集合。

fn partition_in_place<'a, T, P>(self, predicate: P) -> usize where
    T: 'a,
    Self: DoubleEndedIterator<Item = &'a mut T>,
    P: FnMut(&T) -> bool, 

🔬 This is a nightly-only experimental API. (iter_partition_in_place #62543)

根据给定的谓词，对迭代器的元素进行就地重新排序，以使所有返回 true 的元素都在所有返回 false 的元素之前。 返回找到的 true 元素的数量。

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

🔬 This is a nightly-only experimental API. (iter_is_partitioned #62544)

检查此迭代器的元素是否根据给定的谓词进行了分区，以便所有返回 true 的元素都在所有返回 false 的元素之前。

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

一个迭代器方法，它只要成功返回就应用函数，并产生单个最终值。

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

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

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

通过应用操作将每个元素 fold 到一个累加器中，返回最终结果。

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

通过重复应用缩减操作，将元素缩减为一个。

fn try_reduce<F, R>(
    &mut self,
    f: F
) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType where
    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 操作，将元素归约为单个元素。 如果闭包返回失败，则失败会立即传播给调用者。

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

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

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

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

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

搜索满足谓词的迭代器的元素。

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

将函数应用于迭代器的元素，并返回第一个非 None 的结果。

fn try_find<F, R>(
    &mut self,
    f: F
) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType where
    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 的结果或第一个错误。

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

在迭代器中搜索元素，并返回其索引。

fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
    P: FnMut(Self::Item) -> bool,
    Self: ExactSizeIterator + DoubleEndedIterator, 

从右侧搜索迭代器中的元素，并返回其索引。

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

返回迭代器的最大元素。

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

返回迭代器的最小元素。

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

返回给出指定函数最大值的元素。

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

返回给出相对于指定比较函数的最大值的元素。

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

返回给出指定函数中最小值的元素。

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

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

fn rev(self) -> Rev<Self> where
    Self: DoubleEndedIterator, 

反转迭代器的方向。

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

将成对的迭代器转换为一对容器。

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

创建一个迭代器，该迭代器将复制其所有元素。

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

创建一个迭代器，该迭代器将克隆所有元素。

fn cycle(self) -> Cycle<Self> where
    Self: Clone, 

不断重复的迭代器。

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

对迭代器的元素求和。

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

遍历整个迭代器，将所有元素相乘

fn cmp<I>(self, other: I) -> Ordering where
    I: IntoIterator<Item = Self::Item>,
    Self::Item: Ord, 

字典顺序 将这个 Iterator 的元素与另一个的元素进行比较。

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

🔬 This is a nightly-only experimental API. (iter_order_by #64295)

字典顺序 根据指定的比较函数将这个 Iterator 的元素与另一个 Iterator 的元素进行比较。

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

字典顺序 将这个 Iterator 的元素与另一个的元素进行比较。

fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering> where
    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 的元素进行比较。

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

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

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

🔬 This is a nightly-only experimental API. (iter_order_by #64295)

关于指定的相等函数，确定 Iterator 的元素是否与另一个元素相等。

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

确定此 Iterator 的元素是否与另一个元素不相等。

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

确定此 Iterator 的元素是否比另一个元素少 按字典顺序。

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

确定此 Iterator 的元素是否 按字典顺序 小于或等于另一个元素。

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

确定此 Iterator 的元素是否大于另一个元素的 按字典顺序。

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

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

fn is_sorted(self) -> bool where
    Self::Item: PartialOrd<Self::Item>, 

🔬 This is a nightly-only experimental API. (is_sorted #53485)

检查此迭代器的元素是否已排序。

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

🔬 This is a nightly-only experimental API. (is_sorted #53485)

检查此迭代器的元素是否使用给定的比较器函数进行排序。

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

🔬 This is a nightly-only experimental API. (is_sorted #53485)

检查此迭代器的元素是否使用给定的键提取函数进行排序。

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

pub fn cmp(&self, other: &Box<T, A>) -> Ordering

此方法返回 self 和 other 之间的 Ordering。

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

比较并返回两个值中的最大值。

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

比较并返回两个值中的最小值。

fn clamp(self, min: Self, max: Self) -> Self

将值限制在某个时间间隔内。

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

pub fn eq(&self, other: &Box<T, A>) -> bool

此方法测试 self 和 other 值是否相等，并由 == 使用。

pub fn ne(&self, other: &Box<T, A>) -> bool

此方法测试 !=。

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

pub fn partial_cmp(&self, other: &Box<T, A>) -> Option<Ordering>

如果存在，则此方法返回 self 和 other 值之间的顺序。

pub fn lt(&self, other: &Box<T, A>) -> bool

此方法测试的内容少于 (对于 self 和 other)，并且由 < 操作员使用。

pub fn le(&self, other: &Box<T, A>) -> bool

此方法测试小于或等于 (对于 self 和 other)，并且由 <= 运算符使用。

pub fn ge(&self, other: &Box<T, A>) -> bool

此方法测试是否大于或等于 (对于 self 和 other)，并且由 >= 运算符使用。

pub fn gt(&self, other: &Box<T, A>) -> bool

此方法测试大于 (对于 self 和 other)，并且由 > 操作员使用。

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

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

使用给定的格式化程序格式化该值。

impl<R: Read + ?Sized> Read for Box<R>

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

从该源中提取一些字节到指定的缓冲区中，返回读取的字节数。

fn read_buf(&mut self, buf: &mut ReadBuf<'_>) -> Result<()>

🔬 This is a nightly-only experimental API. (read_buf #78485)

从此源中提取一些字节到指定的缓冲区中。

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize>

与 read 相似，不同之处在于它读入缓冲区的一部分。

fn is_read_vectored(&self) -> bool

🔬 This is a nightly-only experimental API. (can_vector #69941)

确定此 Read 是否具有有效的 read_vectored 实现。

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize>

读取所有字节，直到此源中的 EOF 为止，然后将它们放入 buf。

fn read_to_string(&mut self, buf: &mut String) -> Result<usize>

读取这个源中的所有字节，直到 EOF 为止，然后将它们追加到 buf。

fn read_exact(&mut self, buf: &mut [u8]) -> Result<()>

读取填充 buf 所需的确切字节数。

fn read_buf_exact(&mut self, buf: &mut ReadBuf<'_>) -> Result<()>

🔬 This is a nightly-only experimental API. (read_buf #78485)

读取填充 buf 所需的确切字节数。

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

为这个 Read 实例创建一个 “by reference” 适配器。

fn bytes(self) -> Bytes<Self> where
    Self: Sized, 

将此 Read 实例的字节数转换为 Iterator。

fn chain<R: Read>(self, next: R) -> Chain<Self, R> where
    Self: Sized, 

创建一个适配器，将这个流与另一个链接起来。

fn take(self, limit: u64) -> Take<Self> where
    Self: Sized, 

创建一个适配器，最多从中读取 limit 个字节。

impl<S: Seek + ?Sized> Seek for Box<S>

fn seek(&mut self, pos: SeekFrom) -> Result<u64>

在流中寻找以字节为单位的偏移量。

fn stream_position(&mut self) -> Result<u64>

从流的开头返回当前查找位置。

fn rewind(&mut self) -> Result<()>

返回到流的开头。

fn stream_len(&mut self) -> Result<u64>

🔬 This is a nightly-only experimental API. (seek_stream_len #59359)

返回此流的长度 (以字节为单位)。

impl<S> Stream for Box<S, Global> where
    S: Stream + Unpin + ?Sized, 

type Item = <S as Stream>::Item

🔬 This is a nightly-only experimental API. (async_stream #79024)

流产生的项的类型。

pub fn poll_next(
    self: Pin<&mut Box<S, Global>>,
    cx: &mut Context<'_>
) -> Poll<Option<<Box<S, Global> as Stream>::Item>>

🔬 This is a nightly-only experimental API. (async_stream #79024)

尝试拉出该流的下一个值，如果该值尚不可用，则注册当前任务以进行唤醒，如果流已用尽，则返回 None。

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

🔬 This is a nightly-only experimental API. (async_stream #79024)

返回流剩余长度上的边界。

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

pub fn try_from(
    boxed_slice: Box<[T], Global>
) -> Result<Box<[T; N], Global>, <Box<[T; N], Global> as TryFrom<Box<[T], Global>>>::Error>

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

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

Errors

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

type Error = Box<[T], Global>

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

impl<W: Write + ?Sized> Write for Box<W>

fn write(&mut self, buf: &[u8]) -> Result<usize>

在此 writer 中写入一个缓冲区，返回写入的字节数。

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize>

类似于 write，不同之处在于它是从缓冲区切片中写入数据的。

fn is_write_vectored(&self) -> bool

🔬 This is a nightly-only experimental API. (can_vector #69941)

确定此 Writer 是否具有有效的 write_vectored 实现。

fn flush(&mut self) -> Result<()>

刷新此输出流，确保所有中间缓冲的内容均到达其目的地。

fn write_all(&mut self, buf: &[u8]) -> Result<()>

尝试将整个缓冲区写入此 writer。

fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<()>

将格式化的字符串写入此 writer，返回遇到的任何错误。

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<()>

🔬 This is a nightly-only experimental API. (write_all_vectored #70436)

尝试将多个缓冲区写入此 writer。

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

为这个 Write 实例创建一个 “by reference” 适配器。

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

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

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

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

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