Trait Pointer 

pub trait Pointer {
    // Required method
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>;
}

p formatting.

The Pointer trait should format its output as a memory location. This is commonly presented as hexadecimal. For more information on formatters, see the module-level documentation.

Printing of pointers is not a reliable way to discover how Rust programs are implemented. The act of reading an address changes the program itself, and may change how the data is represented in memory, and may affect which optimizations are applied to the code.

The printed pointer values are not guaranteed to be stable nor unique identifiers of objects. Rust allows moving values to different memory locations, and may reuse the same memory locations for different purposes.

There is no guarantee that the printed value can be converted back to a pointer.

Examples

Basic usage with &i32:

let x = &42;

let address = format!("{x:p}"); // this produces something like '0x7f06092ac6d0'

Implementing Pointer on a type:

use std::fmt;

struct Length(i32);

impl fmt::Pointer for Length {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        // use `as` to convert to a `*const T`, which implements Pointer, which we can use

        let ptr = self as *const Self;
        fmt::Pointer::fmt(&ptr, f)
    }
}

let l = Length(42);

println!("l is in memory here: {l:p}");

let l_ptr = format!("{l:018p}");
assert_eq!(l_ptr.len(), 18);
assert_eq!(&l_ptr[..2], "0x");

Required Methods

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

Formats the value using the given formatter.

Errors

This function should return Err if, and only if, the provided Formatter returns Err. String formatting is considered an infallible operation; this function only returns a Result because writing to the underlying stream might fail and it must provide a way to propagate the fact that an error has occurred back up the stack.

Implementors

impl<F> Pointer for F

where F: FnPtr,

impl<M, T> Pointer for Address<M, T>

where M: Mutability, T: ?Sized,

impl<M, T, O> Pointer for BitRef<'_, M, T, O>

where M: Mutability, T: BitStore, O: BitOrder,

Available on non-tarpaulin_include only.

impl<M, T, O> Pointer for BitPtr<M, T, O>

where M: Mutability, T: BitStore, O: BitOrder,

impl<Ptr> Pointer for Pin<Ptr>

where Ptr: Pointer,

impl<T> Pointer for *const T

where T: ?Sized,

impl<T> Pointer for *mut T

where T: ?Sized,

impl<T> Pointer for &T

where T: ?Sized,

impl<T> Pointer for &mut T

where T: ?Sized,

impl<T> Pointer for NonNull<T>

where T: ?Sized,

impl<T> Pointer for AtomicPtr<T>

Available on target_has_atomic_load_store=ptr only.

impl<T> Pointer for FmtBinary<T>

where T: Binary + Pointer,

Available on non-tarpaulin_include only.

impl<T> Pointer for FmtDisplay<T>

where T: Display + Pointer,

Available on non-tarpaulin_include only.

impl<T> Pointer for FmtLowerExp<T>

where T: LowerExp + Pointer,

Available on non-tarpaulin_include only.

impl<T> Pointer for FmtLowerHex<T>

where T: LowerHex + Pointer,

Available on non-tarpaulin_include only.

impl<T> Pointer for FmtOctal<T>

where T: Octal + Pointer,

Available on non-tarpaulin_include only.

impl<T> Pointer for FmtPointer<T>

where T: Pointer,

Available on non-tarpaulin_include only.

impl<T> Pointer for FmtUpperExp<T>

where T: UpperExp + Pointer,

Available on non-tarpaulin_include only.

impl<T> Pointer for FmtUpperHex<T>

where T: UpperHex + Pointer,

Available on non-tarpaulin_include only.

impl<T, A> Pointer for cairo_vm::with_std::boxed::Box<T, A>

where A: Allocator, T: ?Sized,

impl<T, A> Pointer for Rc<T, A>

where A: Allocator, T: ?Sized,

impl<T, A> Pointer for UniqueRc<T, A>

where A: Allocator, T: ?Sized,

impl<T, A> Pointer for Arc<T, A>

where A: Allocator, T: ?Sized,

impl<T, A> Pointer for UniqueArc<T, A>

where A: Allocator, T: ?Sized,

impl<T, A> Pointer for allocator_api2::stable::boxed::Box<T, A>

where A: Allocator, T: ?Sized,

impl<T, O> Pointer for BitBox<T, O>

where O: BitOrder, T: BitStore,

impl<T, O> Pointer for BitSlice<T, O>

where T: BitStore, O: BitOrder,

impl<T, O> Pointer for BitVec<T, O>

where O: BitOrder, T: BitStore,