Struct sgx_tstd::boxed::Box1.0.0[−][src]

#[lang = "owned_box"]
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>`
[src]

ⓘImportant traits for Box
Important traits for Box
`impl Iterator for Box where I: Iterator + ?Sized, type Item = ::Item;`
`pub fn new(x: T) -> Box<T>`
[src]

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

This doesn't actually allocate if T is zero-sized.

Examples

let five = Box::new(5);

`impl<T> Box<T> where T: ?Sized,`
[src]

ⓘImportant traits for Box
Important traits for Box
`impl Iterator for Box where I: Iterator + ?Sized, type Item = ::Item;`
`pub unsafe fn from_raw(raw: *mut T) -> Box<T>`
1.4.0
[src]

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.

Examples

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

`pub fn into_raw(b: Box<T>) -> *mut T`
1.4.0
[src]

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.

Note: this is an associated function, which means that you have to call it as Box::into_raw(b) instead of b.into_raw(). This is so that there is no conflict with a method on the inner type.

Examples

let x = Box::new(5);
let ptr = Box::into_raw(x);

`pub fn into_raw_non_null(b: Box<T>) -> NonNull<T>`
[src]

🔬 This is a nightly-only experimental API. (box_into_raw_non_null)

Consumes the Box, returning the wrapped pointer as NonNull<T>.

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 NonNull<T> pointer into a raw pointer and back into a Box with the Box::from_raw function.

Note: this is an associated function, which means that you have to call it as Box::into_raw_non_null(b) instead of b.into_raw_non_null(). This is so that there is no conflict with a method on the inner type.

Examples

#![feature(box_into_raw_non_null)]

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

`pub fn leak<'a>(b: Box<T>) -> &'a mut T where T: 'a,`
1.26.0
[src]

Consumes and leaks the Box, returning a mutable reference, &'a mut T. Here, the lifetime 'a may be chosen to be 'static.

This function is mainly useful for data that lives for the remainder of the program's life. Dropping the returned reference will cause a memory leak. If this is not acceptable, the reference should first be wrapped with the Box::from_raw function producing a Box. This Box can then be dropped which will properly destroy T and release the allocated memory.

Note: this is an associated function, which means that you have to call it as Box::leak(b) instead of b.leak(). This is so that there is no conflict with a method on the inner type.

Examples

Simple usage:

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

Unsized data:

fn main() {
    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]);
}

`impl Box<Any + 'static>`
[src]

`pub fn downcast<T>(self) -> Result<Box<T>, Box<Any + 'static>> where T: Any,`
[src]

Attempt to downcast the box to a concrete type.

Examples

use std::any::Any;

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

fn main() {
    let my_string = "Hello World".to_string();
    print_if_string(Box::new(my_string));
    print_if_string(Box::new(0i8));
}

`impl Box<Any + 'static + Send>`
[src]

`pub fn downcast<T>(self) -> Result<Box<T>, Box<Any + 'static + Send>> where T: Any,`
[src]

Attempt to downcast the box to a concrete type.

Examples

use std::any::Any;

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

fn main() {
    let my_string = "Hello World".to_string();
    print_if_string(Box::new(my_string));
    print_if_string(Box::new(0i8));
}

Trait Implementations

`impl<T> Ord for Box<T> where T: Ord + ?Sized,`
[src]

`fn cmp(&self, other: &Box<T>) -> Ordering`
[src]

This method returns an Ordering between self and other. Read more

`fn max(self, other: Self) -> Self`
1.21.0
[src]

Compares and returns the maximum of two values. Read more

`fn min(self, other: Self) -> Self`
1.21.0
[src]

Compares and returns the minimum of two values. Read more

`impl ExactSizeIterator for Box where I: ExactSizeIterator + ?Sized,`
[src]

`fn len(&self) -> usize`
[src]

Returns the exact number of times the iterator will iterate. Read more

`fn is_empty(&self) -> bool`
[src]

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

Returns whether the iterator is empty. Read more

`impl<T> Pointer for Box<T> where T: ?Sized,`
[src]

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

Formats the value using the given formatter.

`impl<T> DerefMut for Box<T> where T: ?Sized,`
[src]

`fn deref_mut(&mut self) -> &mut T`
[src]

Mutably dereferences the value.

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

ⓘImportant traits for Box
Important traits for Box
`impl Iterator for Box where I: Iterator + ?Sized, type Item = ::Item;`
`fn default() -> Box<[T]>`
[src]

Returns the "default value" for a type. Read more

`impl Default for Box<str>`
1.17.0
[src]

ⓘImportant traits for Box
Important traits for Box
`impl Iterator for Box where I: Iterator + ?Sized, type Item = ::Item;`
`fn default() -> Box<str>`
[src]

Returns the "default value" for a type. Read more

`impl<T> Default for Box<T> where T: Default,`
[src]