Module core::ptr1.0.0[−][src]

Manually manage memory through raw pointers.

Safety

Many functions in this module take raw pointers as arguments and dereference them. For this to be safe, these pointers must be valid. A valid pointer is one that satisfies all of the following conditions:

The pointer is not null.
The pointer is not dangling (it does not point to memory which has been freed).
The pointer satisfies LLVM's pointer aliasing rules.

Valid pointers are not necessarily properly aligned. However, most functions require their arguments to be properly aligned, and will explicitly state this requirement in the Safety section. Notable exceptions to this are read_unaligned and write_unaligned.

Re-exports

pub use intrinsics::copy_nonoverlapping;

pub use intrinsics::copy;

pub use intrinsics::write_bytes;

Structs

NonNull

*mut T but non-zero and covariant.

Functions

drop_in_place ^⚠	Executes the destructor (if any) of the pointed-to value.
eq	Compare raw pointers for equality.
null	Creates a null raw pointer.
null_mut	Creates a null mutable raw pointer.
read ^⚠	Reads the value from `src` without moving it. This leaves the memory in `src` unchanged.
read_unaligned ^⚠	Reads the value from `src` without moving it. This leaves the memory in `src` unchanged.
read_volatile ^⚠	Performs a volatile read of the value from `src` without moving it. This leaves the memory in `src` unchanged.
replace ^⚠	Moves `src` into the pointed `dest`, returning the previous `dest` value.
swap ^⚠	Swaps the values at two mutable locations of the same type, without deinitializing either.
swap_nonoverlapping ^⚠	Swaps `count * size_of::<T>()` bytes between the two regions of memory beginning at `x` and `y`. The two regions must not overlap.
write ^⚠	Overwrites a memory location with the given value without reading or dropping the old value.
write_unaligned ^⚠	Overwrites a memory location with the given value without reading or dropping the old value.
write_volatile ^⚠	Performs a volatile write of a memory location with the given value without reading or dropping the old value.