Converting a Vec to Vec in-place and with minimal overhead

by

  1. Whenever writing an unsafe block, I strongly encourage people to include a comment on the block explaining why you think the code is actually safe. That type of information is useful for the people who read the code in the future.

  2. Instead of adding comments about the “magic number” 4, just use mem::size_of::<u32>. I’d even go so far as to use size_of for u8 and perform the division for maximum clarity.

  3. You can return the newly-created Vec from the unsafe block.

  4. As mentioned in the comments, “dumping” a block of data like this makes the data format platform dependent; you will get different answers on little endian and big endian systems. This can lead to massive debugging headaches in the future. File formats either encode the platform endianness into the file (making the reader’s job harder) or only write a specific endinanness to the file (making the writer’s job harder).

  5. I’d probably move the whole unsafe block to a function and give it a name, just for organization purposes.

  6. You don’t need to import Vec, it’s in the prelude.

use std::mem;

fn main() {
    let mut vec32 = vec![1u32, 2];

    // I copy-pasted this code from StackOverflow without reading the answer 
    // surrounding it that told me to write a comment explaining why this code 
    // is actually safe for my own use case.
    let vec8 = unsafe {
        let ratio = mem::size_of::<u32>() / mem::size_of::<u8>();

        let length = vec32.len() * ratio;
        let capacity = vec32.capacity() * ratio;
        let ptr = vec32.as_mut_ptr() as *mut u8;

        // Don't run the destructor for vec32
        mem::forget(vec32);

        // Construct new Vec
        Vec::from_raw_parts(ptr, length, capacity)
    };

    println!("{:?}", vec8)
}

Playground

My biggest unknown worry about this code lies in the alignment of the memory associated with the Vec.

Rust’s underlying allocator allocates and deallocates memory with a specific Layout. Layout contains such information as the size and alignment of the pointer.

I’d assume that this code needs the Layout to match between paired calls to alloc and dealloc. If that’s the case, dropping the Vec<u8> constructed from a Vec<u32> might tell the allocator the wrong alignment since that information is based on the element type.

Without better knowledge, the “best” thing to do would be to leave the Vec<u32> as-is and simply get a &[u8] to it. The slice has no interaction with the allocator, avoiding this problem.

Even without interacting with the allocator, you need to be careful about alignment!

See also:

More Related Contents:

  1. How do I convert between numeric types safely and idiomatically?
  2. Temporarily transmute [u8] to [u16]
  3. How do I get an owned value out of a `Box`?
  4. Build a function object with properties in TypeScript
  5. TypeScript or JavaScript type casting
  6. How can I convert a buffer of a slice of bytes (&[u8]) to an integer?
  7. Processing vec in parallel: how to do safely, or without using unstable features?
  8. How to implement a Future or Stream that polls an async fn?
  9. Any difference between type assertions and the newer `as` operator in TypeScript?
  10. TypeScript: Index signature is missing in type
  11. How to tweak LISTAGG to support more than 4000 character in select query?
  12. CASTING attributes for Ordering on a Doctrine2 DQL Query
  13. How can I guarantee that a type that doesn’t implement Sync can actually be safely shared between threads?
  14. What are the differences between Rust’s `String` and `str`?
  15. Does Rust free up the memory of overwritten variables?
  16. How can I convert string to integer in golang
  17. Why does Iterator::take_while take ownership of the iterator?
  18. How can I cast int to enum in C#?
  19. What exactly is a type cast in C/C++?
  20. Why does (int)(object)10m throw “Specified cast is not valid” exception?
  21. Should I worry about the alignment during pointer casting?
  22. casting via void* instead of using reinterpret_cast [duplicate]
  23. Is it possible to implement methods on type aliases?
  24. T-sql – determine if value is integer
  25. How do I move out of a struct field that is an Option?
  26. What is unwrap in Rust, and what is it used for?
  27. Why “explicit lifetime bound required” for Box in struct?
  28. What is the purpose of the unit type in Rust?
  29. How to iterate through a Hashmap, print the key/value and remove the value in Rust?
  30. What is the modern, correct way to do type punning in C++?

Leave a Comment