# Keyword union[−][src]

The Rust equivalent of a C-style union.

A `union` looks like a `struct` in terms of declaration, but all of its fields exist in the same memory, superimposed over one another. For instance, if we wanted some bits in memory that we sometimes interpret as a `u32` and sometimes as an `f32`, we could write:

    union IntOrFloat {
        i: u32,
        f: f32,
    }

    let mut u = IntOrFloat { f: 1.0 };
    // Reading the fields of an union is always unsafe
    assert_eq!(unsafe { u.i }, 1065353216);
    // Updating through any of the field will modify all of them
    u.i = 1073741824;
    assert_eq!(unsafe { u.f }, 2.0);

Run

# Matching on unions

It is possible to use pattern matching on `union`s. A single field name must be used and it must match the name of one of the `union`’s field. Like reading from a `union`, pattern matching on a `union` requires `unsafe`.

    union IntOrFloat {
        i: u32,
        f: f32,
    }

    let u = IntOrFloat { f: 1.0 };

    unsafe {
        match u {
            IntOrFloat { i: 10 } => println!("Found exactly ten!"),
            // Matching the field `f` provides an `f32`.
            IntOrFloat { f } => println!("Found f = {} !", f),
        }
    }

Run

# References to union fields

All fields in a `union` are all at the same place in memory which means borrowing one borrows the entire `union`, for the same lifetime:

ⓘ

    union IntOrFloat {
        i: u32,
        f: f32,
    }

    let mut u = IntOrFloat { f: 1.0 };

    let f = unsafe { &u.f };
    // This will not compile because the field has already been borrowed, even
    // if only immutably
    let i = unsafe { &mut u.i };

    *i = 10;
    println!("f = {} and i = {}", f, i);

Run

See the Reference for more informations on `union`s.