Struct alloc::boxed::Box

pub struct Box<T>(_);

A pointer type for heap allocation.

See the module-level documentation for more.

Methods

impl<T> Box<T>

fn new(x: T) -> Box<T>

Allocates memory on the heap and then moves x into it.

Examples

let x = Box::new(5);

impl<T: ?Sized> Box<T>

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

Unstable

: may be renamed or moved out of Box scope

Constructs a box from the raw pointer.

After this function call, pointer is owned by resulting box. In particular, it means that Box destructor calls destructor of T and releases memory. Since the way Box allocates and releases memory is unspecified, the only valid pointer to pass to this function is the one taken from another Box with boxed::into_raw function.

Function is unsafe, because improper use of this function may lead to memory problems like double-free, for example if the function is called twice on the same raw pointer.

impl Box<Any>

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

Attempt to downcast the box to a concrete type.

impl Box<Any + Send>

fn downcast<T: Any>(self) -> Result<Box<T>, Box<Any + Send>>

Attempt to downcast the box to a concrete type.

Trait Implementations

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

fn default() -> Box<T>

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

fn default() -> Box<[T]>

impl<T: Clone> Clone for Box<T>

fn clone(&self) -> Box<T>

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

impl<T: ?Sized + PartialEq> PartialEq for Box<T>

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

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

impl<T: ?Sized + PartialOrd> PartialOrd for Box<T>

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

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

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

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

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

impl<T: ?Sized + Ord> Ord for Box<T>

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

impl<T: ?Sized + Eq> Eq for Box<T>

impl<T: ?Sized + Hash> Hash for Box<T>

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

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

impl<T: Display + ?Sized> Display for Box<T>

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

impl<T: Debug + ?Sized> Debug for Box<T>

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

impl<T> Pointer for Box<T>

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

impl<T: ?Sized> Deref for Box<T>

type Target = T

fn deref(&self) -> &T

impl<T: ?Sized> DerefMut for Box<T>

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

impl<I: Iterator + ?Sized> Iterator for Box<I>

type Item = I::Item

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

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

fn count(self) -> usize

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

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

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

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

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

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>

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

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

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

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

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

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

fn fuse(self) -> Fuse<Self>

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 F: FnMut(&Self::Item) -> bool, B: Default + Extend<Self::Item>

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

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 position<P>(&mut self, predicate: P) -> Option<usize> where P: FnMut(Self::Item) -> bool

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

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

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

fn min_max(self) -> MinMaxResult<Self::Item> where Self::Item: Ord

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

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

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

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

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

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

fn reverse_in_place<'a, T>(&mut self) where T: 'a, Self: Iterator<Item=&'a mut T> + DoubleEndedIterator

fn sum<S = Self::Item>(self) -> S where S: Add<Self::Item, Output=S> + Zero

fn product<P = Self::Item>(self) -> P where P: Mul<Self::Item, Output=P> + One

impl<I: DoubleEndedIterator + ?Sized> DoubleEndedIterator for Box<I>

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

impl<I: ExactSizeIterator + ?Sized> ExactSizeIterator for Box<I>

fn len(&self) -> usize

impl<'a, A, R> FnOnce<A> for Box<FnBox<A, Output=R> + 'a>

type Output = R

extern "rust-call" fn call_once(self, args: A) -> R

impl<'a, A, R> FnOnce<A> for Box<FnBox<A, Output=R> + Send + 'a>

type Output = R

extern "rust-call" fn call_once(self, args: A) -> R

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