Struct std::raw::TraitObject[][src]

#[repr(C)]pub struct TraitObject {
    pub data: *mut (),
    pub vtable: *mut (),
🔬 This is a nightly-only experimental API. (raw #27751)

The representation of a trait object like &dyn SomeTrait.

This struct has the same layout as types like &dyn SomeTrait and Box<dyn AnotherTrait>.

TraitObject is guaranteed to match layouts, but it is not the type of trait objects (e.g., the fields are not directly accessible on a &dyn SomeTrait) nor does it control that layout (changing the definition will not change the layout of a &dyn SomeTrait). It is only designed to be used by unsafe code that needs to manipulate the low-level details.

There is no way to refer to all trait objects generically, so the only way to create values of this type is with functions like std::mem::transmute. Similarly, the only way to create a true trait object from a TraitObject value is with transmute.

Synthesizing a trait object with mismatched types—one where the vtable does not correspond to the type of the value to which the data pointer points—is highly likely to lead to undefined behavior.



use std::{mem, raw};

// an example trait
trait Foo {
    fn bar(&self) -> i32;

impl Foo for i32 {
    fn bar(&self) -> i32 {
         *self + 1

let value: i32 = 123;

// let the compiler make a trait object
let object: &dyn Foo = &value;

// look at the raw representation
let raw_object: raw::TraitObject = unsafe { mem::transmute(object) };

// the data pointer is the address of `value`
assert_eq!( as *const i32, &value as *const _);

let other_value: i32 = 456;

// construct a new object, pointing to a different `i32`, being
// careful to use the `i32` vtable from `object`
let synthesized: &dyn Foo = unsafe {
     mem::transmute(raw::TraitObject {
         data: &other_value as *const _ as *mut (),
         vtable: raw_object.vtable,

// it should work just as if we had constructed a trait object out of
// `other_value` directly
assert_eq!(, 457);


data: *mut ()
🔬 This is a nightly-only experimental API. (raw #27751)
vtable: *mut ()
🔬 This is a nightly-only experimental API. (raw #27751)

Trait Implementations

impl Clone for TraitObject[src]

impl Copy for TraitObject[src]

Auto Trait Implementations

impl RefUnwindSafe for TraitObject

impl !Send for TraitObject

impl !Sync for TraitObject

impl Unpin for TraitObject

impl UnwindSafe for TraitObject

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized

impl<T> Borrow<T> for T where
    T: ?Sized

impl<T> BorrowMut<T> for T where
    T: ?Sized

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 

impl<T> ToOwned for T where
    T: Clone

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.