Struct std::boxed::Box
[−]
[src]
pub struct Box<T> where T: ?Sized(_);
1.0.0A pointer type for heap allocation.
See the module-level documentation for more.
Methods
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.
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<T> Box<T> where T: ?Sized
unsafe fn from_raw(raw: *mut T) -> Box<T>
1.4.0
Constructs a box from a raw pointer.
After calling this function, the raw pointer is owned by the
resulting Box
. Specifically, the Box
destructor will call
the destructor of T
and free the allocated 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
via the Box::into_raw
function.
This function is unsafe because improper use may lead to memory problems. For example, a double-free may occur if the function is called twice on the same raw pointer.
fn into_raw(b: Box<T>) -> *mut T
1.4.0
Consumes the Box
, returning the wrapped raw pointer.
After calling this function, the caller is responsible for the
memory previously managed by the Box
. In particular, the
caller should properly destroy T
and release the memory. The
proper way to do so is to convert the raw pointer back into a
Box
with the Box::from_raw
function.
Examples
fn main() { let seventeen = Box::new(17); let raw = Box::into_raw(seventeen); let boxed_again = unsafe { Box::from_raw(raw) }; }let seventeen = Box::new(17); let raw = Box::into_raw(seventeen); let boxed_again = unsafe { Box::from_raw(raw) };
impl<T> Box<T>
fn new(x: T) -> Box<T>
Allocates memory on the heap and then places x
into it.
Examples
fn main() { let five = Box::new(5); }let five = Box::new(5);
Trait Implementations
impl<T> AsMut<T> for Box<T> where T: ?Sized
1.5.0
fn as_mut(&mut self) -> &mut T
impl<T> AsRef<T> for Box<T> where T: ?Sized
1.5.0
fn as_ref(&self) -> &T
impl<T> BorrowMut<T> for Box<T> where T: ?Sized
fn borrow_mut(&mut self) -> &mut T
impl<T> Borrow<T> for Box<T> where T: ?Sized
fn borrow(&self) -> &T
impl<T> Clone for Box<[T]> where T: Clone
1.3.0
fn clone(&self) -> Box<[T]>
fn clone_from(&mut self, source: &Self)
impl<T, U> CoerceUnsized<Box<U>> for Box<T> where T: Unsize<U> + ?Sized, U: ?Sized
impl<'a, A, R> FnOnce<A> for Box<FnBox<A, Output=R> + 'a + Send>
impl<'a, A, R> FnOnce<A> for Box<FnBox<A, Output=R> + 'a>
impl<I> ExactSizeIterator for Box<I> where I: ExactSizeIterator + ?Sized
impl<I> DoubleEndedIterator for Box<I> where I: DoubleEndedIterator + ?Sized
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 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 max_by_key<B, F>(self, f: F) -> Option<Self::Item> where B: Ord, F: FnMut(&Self::Item) -> B
1.6.0
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where B: Ord, F: FnMut(&Self::Item) -> B
1.6.0
fn rev(self) -> Rev<Self> where Self: DoubleEndedIterator
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where Self: Iterator<Item=(A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend<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 sum<S>(self) -> S where S: Add<Self::Item, Output=S> + Zero
fn product<P>(self) -> P where P: Mul<Self::Item, Output=P> + One
fn cmp<I>(self, other: I) -> Ordering where I: IntoIterator<Item=Self::Item>, Self::Item: Ord
1.5.0
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where I: IntoIterator, Self::Item: PartialOrd<I::Item>
1.5.0
fn eq<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialEq<I::Item>
1.5.0
fn ne<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialEq<I::Item>
1.5.0
fn lt<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>
1.5.0
fn le<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>
1.5.0
fn gt<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>
1.5.0
fn ge<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>
1.5.0
impl<T> DerefMut for Box<T> where T: ?Sized
fn deref_mut(&mut self) -> &mut T
impl<T> Deref for Box<T> where T: ?Sized
impl<T> Pointer for Box<T> where T: ?Sized
impl<T> Debug for Box<T> where T: Debug + ?Sized
impl<T> Display for Box<T> where T: Display + ?Sized
impl<T> From<T> for Box<T>
1.6.0
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
1.3.0
impl<T> Eq for Box<T> where T: Eq + ?Sized
impl<T> Ord for Box<T> where T: Ord + ?Sized
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> PartialEq<Box<T>> for Box<T> where T: PartialEq<T> + ?Sized
impl Clone for Box<str>
1.3.0
fn clone(&self) -> Box<str>
fn clone_from(&mut self, source: &Self)
impl<T> Clone for Box<T> where T: Clone
fn clone(&self) -> Box<T>
Returns a new box with a clone()
of this box's contents.
Examples
fn main() { let x = Box::new(5); let y = x.clone(); }let x = Box::new(5); let y = x.clone();
fn clone_from(&mut self, source: &Box<T>)
Copies source
's contents into self
without creating a new allocation.
Examples
fn main() { let x = Box::new(5); let mut y = Box::new(10); y.clone_from(&x); assert_eq!(*y, 5); }let x = Box::new(5); let mut y = Box::new(10); y.clone_from(&x); assert_eq!(*y, 5);
impl<T> Default for Box<[T]>
impl<T> Default for Box<T> where T: Default
impl<T> Boxed for Box<T>
type Data = T
placement_new_protocol
#27779)type Place = IntermediateBox<T>
placement_new_protocol
#27779)unsafe fn finalize(b: IntermediateBox<T>) -> Box<T>
placement_new_protocol
#27779)