What is a fat pointer

What is a "fat pointer" in Rust?

The term "bold pointer" refers to references and raw pointers Types With dynamic size (DSTs) - Slices or Trait Objects. A bold pointer contains a pointer and some information that makes daylight saving time "complete" (such as its length).

The most common types in Rust are no Daylight Saving Times, but has a fixed size that is known at compile time. These types implement the feature. Even types that maintain a dynamic size heap buffer (like) know exactly how many bytes an instance needs on the stack. There are currently four different types of daylight saving time in Rust.


Discs (and)

The type (for everyone) has a dynamic size (as does the special type "String Slice"). Therefore, you usually only see it as or, that is, behind a reference. This reference is a so-called "fat pointer". Let's check:

This prints (with some cleanup):

So we see that a reference to a normal type is like 8 bytes in size, as is a reference to an array. These two types are not summer times. But as with a daylight saving time, the reference to it is twice as large. In the case of slices, the extra data that "completes" daylight saving time is simply the length. So you could say that the representation is something like this:


Feature objects ()

If characteristics are used as characteristic objects (that is, type deleted, sent dynamically), these characteristic objects are summer times. Example:

This prints (with some cleanup):

Again, it is only 8 bytes because it is a normal type. But it is a feature object and is therefore dynamically dimensioned. As such, it is 16 bytes in size.

In the case of feature objects, the additional data that completes daylight saving time is a pointer to the vtable (the vptr). I can't fully explain the concept of vtables and vptrs here, but they are used to invoke the correct method implementation in this virtual shipping context. The vtable is a static data item that basically only contains one function pointer for each method. In this way, a reference to a feature object is basically represented as:

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


Custom daylight saving times

It is actually possible to create your own daylight saving times by having a structure where the last field is daylight saving time. However, this is rather rare. A prominent example is.

A bold pointer is also a reference or pointer to custom daylight saving time. The additional data depends on the type of daylight saving time within the structure.


Exception: external types

The function was introduced in RFC 1861. External types are also daylight saving times, but pointers to them are no fat pointer. Or more precisely, as the RFC puts it:

In Rust, pointers to daylight saving time contain metadata about the referenced object. For strings and slices this is the length of the buffer, for trait objects the vtable of the object. For external types, the metadata is simple. This means that a pointer to an external type is the same size as a (that is, it is not a "fat pointer").

However, unless you are interacting with a C interface, you probably never need to deal with these external types.




Above we saw the sizes for immutable references. Bold pointers work the same way for changeable references, unchangeable raw pointers, and changeable raw pointers: