How to get the next pointer?

Question

I have a function implemented in C, and I want to write a function in Rust with the same interface. The function receives a pointer to the beginning of the array (win8_t *) and the length of the array. I need to be able to run through the array.

There must be a better way to get the next value, but now I can do this strange thing:

use std::mem;
pub extern "C" fn print_next(i: *const u8) {
    let mut ii = unsafe { mem::transmute::<*const u8, i64>(i) };
    ii += 1;
    let iii = unsafe { mem::transmute::<i64, *const u8>(ii) };
    let jj = unsafe { *iii };
    println!("{}", jj); // jj is next value
}

Answer 1

As Shepmaster said, you probably need to provide the length of the slice.

Most of the time you're working with pointers, your function will be unsafe (because you usually need to dereference it at some point). It might be a good idea to mark them unsafe to delegate the safety responsibility to the caller.

Here are some examples using offset and from_raw_slice:

use std::mem;
use std::slice;

// unsafe!
pub extern "C" fn print_next(i: *const u8) {
    let mut ii = unsafe { mem::transmute::<*const u8, i64>(i) };
    ii += 1;
    let iii = unsafe { mem::transmute::<i64, *const u8>(ii) };
    let jj = unsafe { *iii };
    println!("{}", jj); // jj is next value
}

// unsafe!
pub unsafe extern "C" fn print_next2(i: *const u8) {
    let j = *i.offset(1);
    println!("{}", j);
}

// (less but still ...) unsafe!
pub unsafe extern "C" fn print_next3(i: *const u8, len: usize) {
    let slice = slice::from_raw_parts(i, len);
    // we are not checking the size ... so it may panic!
    println!("{}", slice[1]);
}

fn main() {
    let a = [9u8, 4, 6, 7];
    print_next(&a as *const u8);
    unsafe {
        print_next2(&a[1] as *const u8);
        print_next3(&a[2] as *const u8, 2);
    }

    // what if I print something not in a??
    print_next(&a[3] as *const u8); // BAD
    unsafe { 
        print_next2(&a[3] as *const u8); // BAD
        print_next3(&a[3] as *const u8, 2); // as bad as others, length is wrong

        print_next3(&a[3] as *const u8, 1); // panic! out of bounds
    }
}