Struct Global 

pub struct Global;

A wrapper for the global allocator.

This type implements the Allocator trait by forwarding calls to the allocator registered with the #[global_allocator] attribute if there is one, or the std crate’s default.

Global is not “the global allocator”, but a wrapper for it. If the global allocator used Global, it would call itself recursively. To avoid this, Global does not implement GlobalAlloc.

Similar to alloc, dealloc, and the other global allocation functions, when and how calls are forwarded to the allocator registered with #[global_allocator] is unspecified. See their safety docs for more information.

In particular, even if you know which allocator was registered as the global allocator, calling it directly is not the same as calling Global. You cannot deallocate memory from one using the other.

Global must be treated like an opaque allocator that only guarantees the contract described in the docs of Allocator, as well as the following:

• All instances of Global are equivalent.
• Allocations from Global are only invalidated by calls to de-/reallocating functions. If no such call is made, then the allocation will live for the rest of the program.
• The global allocation functions in the alloc module are equivalent to the methods on Global, except that they disallow zero-sized allocations, and implicitly ignore any returned excess size. In particular, you may deallocate memory from alloc::alloc using Global.deallocate and vice-versa.

Note that the current implementation of Global does not take advantage of some features of Allocator, such as zero-sized allocations (which currently return a dangling pointer) and overallocating. This may change in the future. You must not rely on it for correctness!

Trait Implementations

impl Allocator for Global

fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError>

Attempts to allocate a block of memory.

fn allocate_zeroed(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError>

Behaves like allocate, but also ensures that the returned memory is zero-initialized.

unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout)

Deallocates the memory referenced by ptr.

unsafe fn grow( &self, ptr: NonNull<u8>, old_layout: Layout, new_layout: Layout, ) -> Result<NonNull<[u8]>, AllocError>

Attempts to extend the memory block.

unsafe fn grow_zeroed( &self, ptr: NonNull<u8>, old_layout: Layout, new_layout: Layout, ) -> Result<NonNull<[u8]>, AllocError>

Behaves like grow, but also ensures that the new contents are set to zero before being returned.

unsafe fn shrink( &self, ptr: NonNull<u8>, old_layout: Layout, new_layout: Layout, ) -> Result<NonNull<[u8]>, AllocError>

Attempts to shrink the memory block.

impl AllocatorClone for Global

impl AllocatorNightly for Global

impl Clone for Global

fn clone(&self) -> Global

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Global

impl Debug for Global

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

Formats the value using the given formatter.

impl Default for Global

fn default() -> Global

Returns the “default value” for a type.

impl StaticAllocator for Global