How to traverse character elements of *const char pointer in Rust?

I'm new to Rust programing and I have a bit of difficulty when this language is different from C Example, I have a C function as follows:

bool check(char* data, int size){
    int i;
    for(i = 0; i < size; i++){
        if( data[i] != 0x00){
            return false;
        }
    }
    return true;
}

How can I convert this function to Rust? I tried it like C, but it has Errors :((

First off, I assume that you want to use as little unsafe code as possible. Otherwise there really isn't any reason to use Rust in the first place, as you forfeit all the advantages it brings you.

Depending on what data represents, there are multiple ways to transfer this to Rust.

First off: Using pointer and length as two separate arguments is not possible in Rust without unsafe. It has the same concept, though; it's called slices. A slice is exactly the same as a pointer-size combination, just that the compiler understands it and checks it for correctness at compile time.

That said, a char* in C could actually be one of four things. Each of those things map to different types in Rust:

• Binary data whose deallocation is taken care of somewhere else (in Rust terms: borrowed data)
  • maps to &[u8], a slice. The actual content of the slice is:
    • the address of the data as *u8 (hidden from the user)
    • the length of the data as usize
• Binary data that has to be deallocated within this function after using it (in Rust terms: owned data)
  • maps to Vec<u8>; as soon as it goes out of scope the data is deleted
  • actual content is:
    • the address of the data as *u8 (hidden from the user)
    • the length of the data as usize
    • the size of the allocation as usize. This allows for efficient push()/pop() operations. It is guaranteed that the length of the data does not exceed the size of the allocation.
• A string whose deallocation is taken care of somewhere else (in Rust terms: a borrowed string)
  • maps to &str, a so called string slice.
  • This is identical to &[u8] with the additional compile time guarantee that it contains valid UTF-8 data.
• A string that has to be deallocated within this function after using it (in Rust terms: an owned string)
  • maps to String
  • same as Vec<u8> with the additional compile time guarantee that it contains valid UTF-8 data.

You can create &[u8] references from Vec<u8>'s and &str references from Strings.

Now this is the point where I have to make an assumption. Because the function that you posted checks if all of the elements of data are zero, and returns false if if finds a non-zero element, I assume the content of data is binary data. And because your function does not contain a free call, I assume it is borrowed data.

With that knowledge, this is how the given function would translate to Rust:

fn check(data: &[u8]) -> bool {
    for d in data {
        if *d != 0x00 {
            return false;
        }
    }
    true
}

fn main() {
    let x = vec![0, 0, 0];
    println!("Check {:?}: {}", x, check(&x));

    let y = vec![0, 1, 0];
    println!("Check {:?}: {}", y, check(&y));
}

Check [0, 0, 0]: true
Check [0, 1, 0]: false

This is quite a direct translation; it's not really idiomatic to use for loops a lot in Rust. Good Rust code is mostly iterator based; iterators are most of the time zero-cost abstraction that can get compiled very efficiently.

This is how your code would look like if rewritten based on iterators:

fn check(data: &[u8]) -> bool {
    data.iter().all(|el| *el == 0x00)
}

fn main() {
    let x = vec![0, 0, 0];
    println!("Check {:?}: {}", x, check(&x));

    let y = vec![0, 1, 0];
    println!("Check {:?}: {}", y, check(&y));
}

Check [0, 0, 0]: true
Check [0, 1, 0]: false

The reason this is more idiomatic is that it's a lot easier to read for someone who hasn't written it. It clearly says "return true if all elements are equal to zero". The for based code needs a second to think about to understand if its "all elements are zero", "any element is zero", "all elements are non-zero" or "any element is non-zero".

Note that both versions compile to the exact same bytecode.

Also note that, unlike the C version, the Rust borrow checker guarantees at compile time that data is valid. It's impossible in Rust (without unsafe) to produce a double free, a use-after-free, an out-of-bounds array access or any other kind of undefined behaviour that would cause memory corruption.

This is also the reason why Rust doesn't do pointers without unsafe - it needs the length of the data to check out-of-bounds errors at runtime. That means, accessing data via [] operator is a little more costly in Rust (as it does perform an out-of-bounds check every time), which is the reason why iterator based programming is a thing. Iterators can iterate over data a lot more efficient than directly accessing it via [] operators.