How do you set, clear and toggle a single bit in Rust?

by

Like many other languages, the bitwise operators & (bitwise AND), | (bitwise OR), ^ (bitwise XOR) exist:

fn main() {
    let mut byte: u8 = 0b0000_0000;

    byte |= 0b0000_1000; // Set a bit
    println!("0b{:08b}", byte);

    byte &= 0b1111_0111; // Unset a bit
    println!("0b{:08b}", byte);

    byte ^= 0b0000_1000; // Toggle a bit
    println!("0b{:08b}", byte);
}

The main difference from other languages is in bitwise NOT, which uses ! instead of ~:

fn main() {
    let mut byte: u8 = 0b0000_0000;

    byte = !byte; // Flip all bits
    println!("0b{:08b}", byte);
}

You can also shift bits left or right:

fn main() {
    let mut byte: u8 = 0b0000_1000;

    byte <<= 1; // shift left one bit
    println!("0b{:08b}", byte);

    byte >>= 1; // shift right one bit
    println!("0b{:08b}", byte);
}

There are many other conceptual things that ultimately do bit-level manipulation that are not expressed with operators. Check out the documentation for an integer for examples. One interesting example is leading_zeros. Here is how to rotate by a certain number of bits:

fn main() {
    let mut byte: u8 = 0b1000_0000;

    byte = byte.rotate_left(1); // rotate left one bit
    println!("0b{:08b}", byte);

    byte = byte.rotate_right(1); // rotate right one bit
    println!("0b{:08b}", byte);
}

The book has some more information

More Related Contents:

  1. Lifetime error when creating a function that returns a value implementing serde::Deserialize
  2. Passing mutable self reference to method of owned object
  3. What does “cannot move out of index of” mean?
  4. How to convert ‘struct’ to ‘&[u8]’?
  5. How does the mechanism behind the creation of boxed traits work?
  6. What is the syntax: `instance.method::()`?
  7. Why does passing a closure to function which accepts a function pointer not work?
  8. “expected type parameter, found struct”
  9. Adding an append method to a singly linked list
  10. How do you actually use dynamically sized types in Rust?
  11. Why do I need rebinding/shadowing when I can have mutable variable binding?
  12. Borrowing references to attributes in a struct
  13. How can I put an async function into a map in Rust?
  14. How to operate on 2 mutable slices of a Rust array?
  15. Mutating one field while iterating over another immutable field
  16. How can I use a module from outside the src folder in a binary project, such as for integration tests or benchmarks?
  17. How to match on data type in Rust?
  18. Why does Rust allow mutation through a reference field using an immutable binding?
  19. Multiple return types from a method
  20. How to end a borrow in a match or if let expression?
  21. Why does this mutable borrow live beyond its scope?
  22. Why does creating a mutable reference to a dereferenced mutable reference work?
  23. Cannot borrow `x` as mutable more than once at a time
  24. Removing elements from a Vec based on some condition [duplicate]
  25. What’s the difference between using the return statement and omitting the semicolon in Rust?
  26. How to print a Vec?
  27. How to get an Option’s value or set it if it’s empty?
  28. How to set a field in a struct with an empty value?
  29. Why does using Option::map to Box::new a trait object not work?
  30. How can I convert a hex string to a u8 slice?

Leave a Comment