Change C array element via Rust FFI [duplicate]

Question

I'm using Rust to test some C code:

lol.c

#include "lol.h"
int a[10]; //Assume lol.h has an extern declaration for a[10]

lib.rs

extern "C" {
    static a: *mut i32;
}

fn set_a(val: i32, index: usize) {
    assert!(index < 10);
    unsafe {
        a[index] = val;
    }
}

fn get_a(index: usize) {
    assert!(index < 10);
    unsafe { a[index] }
}

I used the cc crate to compile and link lol.o. How do I write the set_a and get_a functions? The compiler says:

error[E0608]: cannot index into a value of type `*mut i32`
 --> src/main.rs:8:9
  |
8 |         a[index] = val;
  |         ^^^^^^^^

error[E0608]: cannot index into a value of type `*mut i32`
  --> src/main.rs:14:14
   |
14 |     unsafe { a[index] }
   |              ^^^^^^^^

Aside: the Rust equivalent of C's int is not i32; it's c_int in the libc crate. — DK.
– DK., Commented Feb 7, 2018 at 9:54

Stefan · Accepted Answer · 2018-02-07 09:37:48Z

7

You could use the offset method to find a single element, or use std::slice::from_raw_parts_mut to create a slice from pointer and (possibly dynamic) length, or use static mut a: *mut [i32; 10] in the first place (use (*a)[index] to use it).

But: I'm pretty sure that int a[10]; from C doesn't export a location of a pointer to that array, it exports the location of the array (i.e the location of the first element), and extern in Rust expects a location to a value of the given type (i.e. it is implemented as a pointer on both sides) , so I'd try this:

extern "C" {
    static mut a: [i32; 10];
}

fn set_a(val: i32, index: usize) {
    unsafe {
        a[index] = val;
    }
}

fn get_a(index: usize) -> i32 {
    unsafe { a[index] }
}

answered Feb 7, 2018 at 9:37

Stefan

5,5392 gold badges29 silver badges45 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

KDN Over a year ago

This was exactly what I wanted. Worked perfectly

Shepmaster · Accepted Answer · 2018-02-07 14:35:12Z

2

Use:

a.offset(x) as *mut i32

Like this:

extern crate libc;

use libc::malloc;
use std::mem::size_of;

unsafe fn zero(data: *mut u32, length: usize) {
    for i in 0..length - 1 {
        let ptr = data.offset(i as isize) as *mut u32;
        *ptr = 0;
    }
}

unsafe fn set(data: *mut u32, offset: usize, value: u32) {
    let ptr = data.offset(offset as isize) as *mut u32;
    *ptr = value;
}

unsafe fn get(data: *mut u32, offset: usize) -> u32 {
    let ptr = data.offset(offset as isize) as *mut u32;
    return *ptr;
}

unsafe fn alloc(length: usize) -> *mut u32 {
    let raw = malloc(length * size_of::<*mut u32>());
    return raw as *mut u32;
}

fn main() {
    unsafe {
        let data = alloc(10);
        zero(data, 10);

        println!("{:?}", get(data, 4));

        set(data, 4, 100);
        println!("{:?}", get(data, 4));
    }
}

edited Feb 7, 2018 at 14:35

Shepmaster

439k116 gold badges1.3k silver badges1.5k bronze badges

answered Feb 7, 2018 at 9:18

Doug

35.6k40 gold badges189 silver badges231 bronze badges

2 Comments

KDN Over a year ago

I have two questions? Is the usize to isize because C indexing is different from Rust? Also why did you have to malloc. The space is already allocated in C right?

Doug Over a year ago

@KDN malloc was just an example (the code above runs on play.rust-lang.org). Obviously in your situation there's no need to malloc. The usize thing is because it's legal in C (and meaningful sometimes) to use x[-1]; so offset() can take a -ve number. In this case it's not meaningful to allow -ve values, so I made it usize instead of isize, but it's arbitrary. Just use isize if you don't care.

Collectives™ on Stack Overflow

Change C array element via Rust FFI [duplicate]

2 Answers 2

1 Comment

2 Comments

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

2 Comments

Linked

Related