Struct collections::boxed::Box [] [src]

pub struct Box<T> where T: ?Sized(_);

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

fn main() { let x = Box::new(5); }
let x = Box::new(5);

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

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

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 Box::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.

fn into_raw(b: Box<T>) -> *mut T

Unstable

: may be renamed

Consumes the Box, returning the wrapped raw pointer.

After call to this function, caller is responsible for the memory previously managed by Box, in particular caller should properly destroy T and release memory. The proper way to do it is to convert pointer back to Box with Box::from_raw function, because Box does not specify, how memory is allocated.

Examples

#![feature(box_raw)] fn main() { let seventeen = Box::new(17u32); let raw = Box::into_raw(seventeen); let boxed_again = unsafe { Box::from_raw(raw) }; }
#![feature(box_raw)]

let seventeen = Box::new(17u32);
let raw = Box::into_raw(seventeen);
let boxed_again = unsafe { Box::from_raw(raw) };

impl Box<Any + 'static>

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

Attempt to downcast the box to a concrete type.

impl Box<Any + 'static + Send>

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

Attempt to downcast the box to a concrete type.

Trait Implementations

impl<T> Boxed for Box<T>

type Data = T

type Place = IntermediateBox<T>

unsafe fn finalize(b: IntermediateBox<T>) -> Box<T>

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

fn default() -> Box<T>

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

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

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

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

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

impl Clone for Box<str>

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

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

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

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

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

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

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> Ord for Box<T> where T: Ord + ?Sized

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

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

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

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

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

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

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

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

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

impl<T> Pointer for Box<T>

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

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

type Target = T

fn deref(&self) -> &T

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

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

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

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 F: FnMut(Self::Item) -> U, U: IntoIterator

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

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 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 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 F: FnMut(&Self::Item) -> B, B: Ord

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 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 Self: Iterator<Item=&'a mut T> + DoubleEndedIterator, T: 'a

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 for Box<I> where I: DoubleEndedIterator + ?Sized

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

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

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> + 'a + Send>

type Output = R

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

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

impl<T> Clone for Box<[T]> where T: Clone

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

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

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

fn borrow(&self) -> &T

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

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