What is a “fat pointer”?

by

The term “fat pointer” is used to refer to references and raw pointers to dynamically sized types (DSTs) – slices or trait objects. A fat pointer contains a pointer plus some information that makes the DST “complete” (e.g. the length).

Most commonly used types in Rust are not DSTs but have a fixed size known at compile time. These types implement the Sized trait. Even types that manage a heap buffer of dynamic size (like Vec<T>) are Sized, as the compiler knows the exact number of bytes a Vec<T> instance will take up on the stack. There are currently four different kinds of DSTs in Rust.

Slices ([T] and str)

The type [T] (for any T) is dynamically sized (so is the special “string slice” type str). That’s why you usually only see it as &[T] or &mut [T], i.e. behind a reference. This reference is a so-called “fat pointer”. Let’s check:

dbg!(size_of::<&u32>());
dbg!(size_of::<&[u32; 2]>());
dbg!(size_of::<&[u32]>());

This prints (with some cleanup):

size_of::<&u32>()      = 8
size_of::<&[u32; 2]>() = 8
size_of::<&[u32]>()    = 16

So we see that a reference to a normal type like u32 is 8 bytes large, as is a reference to an array [u32; 2]. Those two types are not DSTs. But as [u32] is a DST, the reference to it is twice as large. In the case of slices, the additional data that “completes” the DST is simply the length. So one could say the representation of &[u32] is something like this:

struct SliceRef { 
    ptr: *const u32, 
    len: usize,
}

Trait objects (dyn Trait)

When using traits as trait objects (i.e. type erased, dynamically dispatched), these trait objects are DSTs. Example:

trait Animal {
    fn speak(&self);
}

struct Cat;
impl Animal for Cat {
    fn speak(&self) {
        println!("meow");
    }
}

dbg!(size_of::<&Cat>());
dbg!(size_of::<&dyn Animal>());

This prints (with some cleanup):

size_of::<&Cat>()        = 8
size_of::<&dyn Animal>() = 16

Again, &Cat is only 8 bytes large because Cat is a normal type. But dyn Animal is a trait object and therefore dynamically sized. As such, &dyn Animal is 16 bytes large.

In the case of trait objects, the additional data that completes the DST is a pointer to the vtable (the vptr). I cannot fully explain the concept of vtables and vptrs here, but they are used to call the correct method implementation in this virtual dispatch context. The vtable is a static piece of data that basically only contains a function pointer for each method. With that, a reference to a trait object is basically represented as:

struct TraitObjectRef {
    data_ptr: *const (),
    vptr: *const (),
}

(This is different from C++, where the vptr for abstract classes is stored within the object. Both approaches have advantages and disadvantages.)

Custom DSTs

It’s actually possible to create your own DSTs by having a struct where the last field is a DST. This is rather rare, though. One prominent example is std::path::Path.

A reference or pointer to the custom DST is also a fat pointer. The additional data depends on the kind of DST inside the struct.

Exception: Extern types

In RFC 1861, the extern type feature was introduced. Extern types are also DSTs, but pointers to them are not fat pointers. Or more exactly, as the RFC puts it:

In Rust, pointers to DSTs carry metadata about the object being pointed to. For strings and slices this is the length of the buffer, for trait objects this is the object’s vtable. For extern types the metadata is simply (). This means that a pointer to an extern type has the same size as a usize (ie. it is not a “fat pointer”).

But if you are not interacting with a C interface, you probably won’t ever have to deal with these extern types.

Above, we’ve seen the sizes for immutable references. Fat pointers work the same for mutable references, immutable raw pointers and mutable raw pointers:

size_of::<&[u32]>()       = 16
size_of::<&mut [u32]>()   = 16
size_of::<*const [u32]>() = 16
size_of::<*mut [u32]>()   = 16

More Related Contents:

  1. Why is the return type of Deref::deref itself a reference?
  2. Why does printing a pointer print the same thing as printing the dereferenced pointer?
  3. Meaning of ‘&variable’ in arguments/patterns
  4. How to check if two variables point to the same object in memory?
  5. Understanding and relationship between Box, ref, & and *
  6. Pointers vs. values in parameters and return values
  7. Hiding nil values, understanding why Go fails here
  8. X does not implement Y (… method has a pointer receiver)
  9. How do I do a literal *int64 in Go?
  10. Using the extra 16 bits in 64-bit pointers
  11. How to use global var across files in a package?
  12. ” is pointer to interface, not interface” confusion
  13. How can I store reference to the result of an operation in Go?
  14. Copying a struct containing pointers to CUDA device
  15. What does “`str` does not have a constant size known at compile-time” mean, and what’s the simplest way to fix it?
  16. How to get the pointer of return value from function call?
  17. My object is not updated even if I use the pointer to a type to update it
  18. Invoking struct function gives “cannot refer to unexported field or method”
  19. Slicing a slice pointer passed as argument
  20. Cast a struct pointer to interface pointer in Golang
  21. Can the pointer in a struct pointer method be reassigned to another instance?
  22. Dereferencing a map index in Golang
  23. Should pointer comparisons be signed or unsigned in 64-bit x86?
  24. Why should constructor of Go return address?
  25. Range references instead values
  26. In Go HTTP handlers, why is the ResponseWriter a value but the Request a pointer?
  27. Passing by reference and value in Go to functions
  28. Kotlin function parameter: Val cannot be reassigned
  29. Go equivalent of a void pointer in C
  30. What’s the difference between pointer and value in struct?

Leave a Comment