Rust for C-Programmers

6.9 Unsafe Rust and Interoperability with C

By default, Rust enforces memory and thread safety. However, some low-level operations require more freedom than the compiler can validate, which is made possible in unsafe blocks. We will discuss unsafe Rust in more detail in Chapter 25.

6.9.1 Unsafe Blocks

fn main() {
    let mut num = 5;

    unsafe {
        let r1 = &mut num as *mut i32; // Raw pointer
        *r1 += 1;                     // Dereference raw pointer
    }

    println!("num = {}", num);
}

Inside an unsafe block, you can dereference raw pointers or call unsafe functions. It becomes your responsibility to uphold safety requirements.

6.9.2 Interfacing with C

Rust can invoke C functions or be invoked by C code via the extern "C" interface.

Calling C from Rust:

// For the Rust 2024 edition, extern blocks are unsafe
unsafe extern "C" {
    fn puts(s: *const i8);
}

fn main() {
    unsafe {
        puts(b"Hello from Rust!\0".as_ptr() as *const i8);
    }
}

Calling Rust from C:

Rust code:

#![allow(unused)]
fn main() {
#[no_mangle]
pub extern "C" fn add(a: i32, b: i32) -> i32 {
    a + b
}
}

C code:

#include <stdio.h>

extern int add(int a, int b);

int main() {
    int result = add(5, 3);
    printf("Result: %d\n", result);
    return 0;
}

Tools like bindgen can create Rust FFI bindings from C headers automatically.