Appendix B: Rust std for C Programmers

This appendix maps C standard library functions and patterns to their Rust equivalents. If you know the C function, find the Rust way to do the same thing.

I/O: stdio.h -> std::io, std::fs

#![allow(unused)]
fn main() {
// Reading a file in Rust (C equivalent: fopen + fread + fclose)
use std::fs;
let contents = fs::read_to_string("file.txt").expect("read failed");

// Line-by-line reading (C equivalent: fgets loop)
use std::io::{self, BufRead};
let file = fs::File::open("file.txt").expect("open failed");
for line in io::BufReader::new(file).lines() {
    let line = line.expect("read line failed");
    println!("{line}");
}
}

Memory: stdlib.h -> Box, Vec, ownership

#![allow(unused)]
fn main() {
// Heap allocation (C: malloc + use + free)
let boxed = Box::new(42);          // heap-allocated i32
println!("{boxed}");                // auto-deref
// freed automatically when boxed goes out of scope

// Dynamic array (C: malloc + realloc pattern)
let mut v: Vec<i32> = Vec::new();
v.push(1);
v.push(2);
v.push(3);
// no manual realloc or free needed
}

Strings: string.h -> String, &str

#![allow(unused)]
fn main() {
// String operations (C equivalents in comments)
let s = String::from("hello");     // like strdup("hello")
let len = s.len();                 // like strlen(s)
let upper = s.to_uppercase();      // no C equivalent in string.h

// Splitting (C: strtok loop)
let csv = "a,b,c,d";
let parts: Vec<&str> = csv.split(',').collect();
// parts = ["a", "b", "c", "d"]

// Parsing numbers (C: strtol)
let n: i64 = "42".parse().expect("not a number");
}

The &str vs String distinction

C:      const char *  (pointer to existing string)  <-->  &str
        char *buf     (owned, mutable buffer)        <-->  String

Rust rule: use &str for parameters, String for owned data.

Math: math.h -> std::f64, num traits

No -lm flag needed. Math is built into the primitive types.

Process: unistd.h, stdlib.h -> std::process

#![allow(unused)]
fn main() {
// Running a child process (C: fork + exec + wait)
use std::process::Command;

let output = Command::new("ls")
    .arg("-la")
    .output()
    .expect("failed to execute");

println!("stdout: {}", String::from_utf8_lossy(&output.stdout));
println!("exit: {}", output.status);
}

Networking: sys/socket.h -> std::net

#![allow(unused)]
fn main() {
// TCP echo server (C equivalent: socket + bind + listen + accept loop)
use std::net::TcpListener;
use std::io::{Read, Write};

let listener = TcpListener::bind("127.0.0.1:8080").unwrap();
for stream in listener.incoming() {
    let mut stream = stream.unwrap();
    let mut buf = [0u8; 1024];
    let n = stream.read(&mut buf).unwrap();
    stream.write_all(&buf[..n]).unwrap();
}
}

Error Handling: errno -> Result<T, E>

#![allow(unused)]
fn main() {
// The ? operator replaces C error-checking boilerplate
use std::io;
use std::fs;

fn read_config() -> io::Result<String> {
    let contents = fs::read_to_string("/etc/myapp.conf")?;  // returns Err on failure
    Ok(contents)
}
}

Key Traits Every C Programmer Should Know

Read and Write

#![allow(unused)]
fn main() {
use std::io::{Read, Write};

// Anything that implements Read can be read from:
// File, TcpStream, &[u8], Stdin, ...
fn process_input(mut reader: impl Read) -> io::Result<String> {
    let mut buf = String::new();
    reader.read_to_string(&mut buf)?;
    Ok(buf)
}
}

Iterator

Replaces C for-loops over arrays and linked lists.

#![allow(unused)]
fn main() {
// C: for (int i = 0; i < n; i++) sum += arr[i];
let sum: i32 = arr.iter().sum();

// C: filter + transform loop
let even_squares: Vec<i32> = (0..10)
    .filter(|x| x % 2 == 0)
    .map(|x| x * x)
    .collect();
}

Display and Debug

#![allow(unused)]
fn main() {
use std::fmt;

// Display: for user-facing output (like a custom printf format)
impl fmt::Display for MyType {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "MyType({})", self.value)
    }
}

// Debug: for developer output (derive it)
#[derive(Debug)]
struct Point { x: f64, y: f64 }

let p = Point { x: 1.0, y: 2.0 };
println!("{p:?}");  // Point { x: 1.0, y: 2.0 }
}

From and Into

#![allow(unused)]
fn main() {
// From<T>: conversion from one type to another
// Replaces C's explicit casting and conversion functions
let s: String = String::from("hello");
let n: i64 = i64::from(42i32);

// Into<T>: the reverse direction (auto-derived from From)
fn takes_string(s: String) { /* ... */ }
takes_string("hello".into());  // &str -> String via Into
}

Clone and Copy

#![allow(unused)]
fn main() {
// Copy: bitwise copy (like C assignment for simple types)
// Applies to: integers, floats, bool, char, references
let a: i32 = 5;
let b = a;  // copy, both valid

// Clone: explicit deep copy (like manual malloc + memcpy)
let s1 = String::from("hello");
let s2 = s1.clone();  // explicit deep copy
// Both s1 and s2 are valid
}

Concurrency: pthreads -> std::thread, std::sync

#![allow(unused)]
fn main() {
use std::sync::{Arc, Mutex};
use std::thread;

let counter = Arc::new(Mutex::new(0));

let handles: Vec<_> = (0..4).map(|_| {
    let c = Arc::clone(&counter);
    thread::spawn(move || {
        let mut num = c.lock().unwrap();
        *num += 1;
    })
}).collect();

for h in handles { h.join().unwrap(); }
println!("Result: {}", *counter.lock().unwrap());
}

Time: time.h -> std::time

#![allow(unused)]
fn main() {
use std::time::Instant;

let start = Instant::now();
// ... work ...
let elapsed = start.elapsed();
println!("Took {elapsed:?}");
}

Collections: Manual C -> std::collections

Quick Conversion Cheatsheet

C type          -->  Rust type
int                  i32
unsigned int         u32
long                 i64 (on 64-bit Linux)
size_t               usize
ssize_t              isize
char                 u8 (byte) or char (Unicode)
char *               &str (borrowed) or String (owned)
void *               *const u8 / *mut u8 or &[u8]
NULL                 None (in Option<T>)
FILE *               File (in std::fs)
bool (C99)           bool
_Bool                bool