Rust.CodeCompared.To/C

C uses printf from <stdio.h> where Rust uses the println! macro. The \n escape must be written explicitly — printf does not add a newline automatically. The int main(void) signature is the C17 convention; return 0 signals success to the operating system. Every C source file that uses printf must include <stdio.h>.

C has no single official build tool — projects use make, CMake, Meson, or raw gcc invocations. Cargo integrates dependency management, building, testing, and formatting in one tool; C's ecosystem splits these across separate programs. The -Wall -Wextra flags enable warnings that catch many common mistakes and should always be used during development.

printf uses C-style format specifiers: %s for strings, %d for integers, %.1f for floats with one decimal place. A literal % is written as %%. Rust's format strings use {} with optional specifiers like {:.1}. fprintf(stderr, ...) is the C equivalent of Rust's eprintln! — it writes to the standard error stream.

In C, all variables are mutable by default — there is no let/let mut distinction. Use const to declare a runtime constant; use #define for compile-time substitution (the preprocessor replaces the name with its value before compilation). C has no type inference — every variable declaration requires an explicit type.

C's built-in int has a platform-dependent width (at least 16 bits). For the fixed-width types that map directly to Rust's i8, i32, u64, etc., include <stdint.h> (C99+). Use size_t for sizes and array indices — it is unsigned and pointer-sized, matching Rust's usize. Format specifiers differ by type: %d for int, %lld for int64_t, %zu for size_t.

C uses float (32-bit) and double (64-bit) matching Rust's f32/f64. Float literals require the f suffix (3.14f); without it, the literal is a double. Math functions like sqrt come from <math.h> and must be linked with -lm. In Rust, math is a method: x.sqrt(); in C it is a free function: sqrt(x).

C had no boolean type until C99, when <stdbool.h> added bool, true, and false. Before that, programmers used int (0 = false, non-zero = true), and many C APIs still use that convention. printf has no %b specifier for booleans — the ternary condition ? "true" : "false" is the idiomatic way to print them.

C casts use the (type)expression syntax; Rust uses value as Type. Both truncate when converting a float to an integer. The key difference is safety: in Rust, as never causes undefined behavior — out-of-range values wrap or saturate predictably. In C, casting a value outside the target type's range gives implementation-defined behavior for signed types and wraps for unsigned types.

In C, a string literal like "Hello" is a const char* pointer to read-only memory — modifying it is undefined behavior. To get a mutable string, declare a char array (char owned[32] = "World"), which copies the literal onto the stack. All C strings are null-terminated ('\0' at the end); there is no &str/String distinction, only char*.

strlen counts bytes up to (but not including) the null terminator — it has no concept of Unicode code points. For ASCII strings this equals the character count; for UTF-8 strings with multi-byte characters it counts bytes, not characters. There is no standard C function for counting Unicode code points. Unlike Rust's len(), which is O(1) because &str stores its length, strlen is O(n) — it scans until it finds '\0'.

Never compare C strings with == — it compares pointer addresses, not content, and will be false even for identical strings that are different pointers. Always use strcmp for content equality. strcmp returns 0 for equality, a negative value if first < second, positive if greater. strstr returns a pointer to the first occurrence of the substring, or NULL if not found.

snprintf is the safe alternative to sprintf — it always writes a null terminator and never writes beyond the buffer size. Use it for all string formatting in C. The second argument is the total buffer size including the null terminator. Rust's format! returns a String that grows as needed; C requires pre-allocating a buffer large enough for the result.

Prefer strtol over the simpler atoi — atoi returns 0 for invalid input with no way to detect the error, while strtol sets endptr to the first non-numeric character. If endptr equals the input string start or does not point to '\0', parsing failed. Rust's parse() returns Result<T, _> — the error case is part of the type and the compiler forces you to handle it.

C arrays are raw memory blocks with no embedded length. int numbers[5] allocates five consecutive integers on the stack. There is no bounds checking — numbers[10] on a five-element array silently reads or writes memory past the array (undefined behavior). Rust panics on out-of-bounds access in debug mode and performs the check in release builds too. {0} initializes the first element to 0 and zero-fills the rest.

sizeof(array) / sizeof(array[0]) computes the element count, but only when the array name is in scope — once an array is passed to a function and decays to a pointer, its length is lost. This is why C functions that operate on arrays always take a separate count or length parameter. Rust's len() is always available because slices carry their length.

C multidimensional arrays are laid out in row-major order in contiguous memory — matrix[row][column] is at offset row * 3 + column. When passing a 2D array to a function, all dimensions except the first must be specified in the parameter type: void print_matrix(int matrix[][3], int rows). Rust's nested arrays work the same way, but for row in &matrix iterates over references to the inner arrays cleanly.

C has no slice type — a "slice" is expressed as a pointer to the first element plus a separate count. numbers + 1 is pointer arithmetic: it points to the second element, one sizeof(int) byte past the start. Passing the wrong count is a common bug in C because the compiler cannot detect it. Rust's slice (&[i32]) carries both the pointer and the length in one value, and bounds are always checked.

In Rust, if is an expression that produces a value — every arm returns the same type. In C, if is a statement and cannot be used on the right side of an assignment. A simple conditional assignment can use the ternary operator condition ? a : b, but multi-statement bodies must use an if/else block with a pre-declared variable.

C's for (init; condition; increment) is the classic three-part loop. There is no for element in collection syntax — array traversal always requires manual indexing. C has no iterator protocol; Rust's for x in iter works with any type that implements IntoIterator. C++11 added range-based for, but standard C does not have it.

C has a native do { ... } while (condition) loop that always runs the body at least once. Rust achieves the same pattern with loop { ...; if cond { break; } }. C's while loop is otherwise identical to Rust's. Note that C uses count++ (postfix increment) as a shorthand for count += 1; Rust dropped ++ because it was a source of subtle bugs.

C's switch falls through to the next case unless you add break — forgetting a break is one of the most common C bugs. Rust's match never falls through — each arm is independent. switch only works on integer and character types; Rust's match works on any type and supports patterns, guards, ranges, and destructuring. The compiler warns about unhandled enum variants in match; in C, switch silently ignores missing cases (use -Wswitch to opt into a warning).

C's break and continue apply only to the immediately enclosing loop — there are no labeled loops. Breaking out of nested loops requires a flag variable, a goto, or restructuring into a function that returns early. Rust's labeled loops ('outer:) allow break 'outer to exit any enclosing loop by name, without a flag or goto.

C requires an explicit return statement — there is no implicit last-expression return. Functions declared with no return type default to int in old C; in C17, always write the return type explicitly. A void function returns nothing and omits the return or uses return; to exit early. Function prototypes (declarations without bodies) are needed when a function is called before its definition in the file.

C functions return only one value. To return multiple values, pass pointers as output parameters — the caller allocates the variables and passes their addresses; the function writes through the pointers. This is explicit about what the function modifies, but more verbose than Rust's tuple return. Alternatively, return a struct containing all the values, which is idiomatic in modern C.

C has function pointers (int (*transform)(int)), but they cannot capture surrounding variables — a function pointer is just an address in code memory, not a bundle of code + captured state. To simulate closures in C, callbacks conventionally take a void *context parameter alongside the function pointer: void callback(void *context, int value). Rust's closures automatically capture by reference or by value — no manual context parameter needed.

C's variadic functions use <stdarg.h> — the caller must tell the function how many arguments were passed (or encode the count in a sentinel or format string). There is no runtime introspection. Passing the wrong count or type is undefined behavior; printf trusts the format string to infer argument types, which is why gcc -Wall checks format strings at compile time. Rust avoids variadic functions in safe code; variadic FFI (extern "C") is available for C interoperability.

C structs are pure data containers — they have no methods. All "methods" are free functions that take a pointer to the struct as their first argument (the const Point * parameter mirrors Rust's &self). typedef struct { ... } Name defines the struct and an alias in one step so you can write Point instead of struct Point. The -> operator dereferences a pointer and accesses a field: point->x is shorthand for (*point).x.

C17 supports designated initializers (.name = "Bob") that initialize fields by name in any order — unspecified fields default to zero. Without designators, fields are initialized positionally. C has no #[derive(Debug)]; printing a struct requires manually writing a format string. On the stack, uninitialised struct members contain garbage; zero-initialization with {0} or memset is good practice.

The C convention for "methods" is to name the function with a structname_methodname prefix and take a pointer to the struct as the first parameter. Callers pass &rect explicitly. Rust's impl block binds functions to a type so they are called with dot syntax (rect.area()); C has no such binding. This naming convention is enforced only by discipline — the compiler does not enforce it.

C enums are simply named integer constants — DIRECTION_NORTH is 0, DIRECTION_SOUTH is 1, and so on. They provide no type safety: a variable of type Direction can hold any int value including 99, with no warning. Rust enums are algebraic types with strict exhaustiveness checking in match — the compiler rejects a match that misses any variant. Use uppercase prefixes (DIRECTION_NORTH) to avoid name collisions with variables since C has no namespacing for enum members.

C has no native sum types. The standard idiom combines a discriminant enum (the "tag") with a union for the variant data in a single struct. Reading the wrong union member is undefined behavior — C trusts you to check the tag first. Rust's enum is a safe tagged union: the compiler guarantees that match is exhaustive and prevents accessing non-active variants entirely.

In Rust, & creates a reference; in C, & takes the address of a variable, producing a pointer. Both produce the memory address of the variable. The key difference is safety: Rust's borrow checker enforces at compile time that references don't outlive their data (no dangling pointers) and that mutable and immutable references cannot coexist (no data races). In C, none of these rules are enforced — every pointer access is a leap of faith.

In C, pointer arithmetic is ordinary code — adding n to a pointer advances it by n * sizeof(type) bytes. It is the idiomatic way to traverse arrays; numbers + 1 points to the second element. In Rust, raw pointer arithmetic requires an unsafe block; the normal approach is iterators or indexing. Going past the end of an array is undefined behavior in C; Rust's slice indexing panics on out-of-bounds access.

C uses NULL (a null pointer) to represent "no value" — dereferencing NULL causes a segmentation fault. Every pointer can be NULL, and checking for it is the programmer's responsibility. Rust's Option<T> makes absence explicit in the type: None is a real value, not a special pointer. The compiler forces you to handle None before accessing the inner value — there is no null pointer in safe Rust.

Rust's Box<T> is a heap pointer with automatic cleanup — the Drop trait calls free when the Box goes out of scope. In C, malloc and free must always be paired manually. Forgetting free causes a memory leak; calling it twice (double-free) corrupts the heap; using a pointer after free (use-after-free) is undefined behavior. All three are silent: the compiler does not warn about any of them.

Rust's Vec<T> is a dynamic array with built-in length, capacity, and automatic resizing — it calls malloc/realloc/free internally. In C, you implement this yourself: track length and capacity manually, double capacity when full, call realloc to resize, and free when done. Most C projects use a utility library (glib's GArray, or a custom header) to provide a growable-array abstraction.

calloc(n, size) allocates n * size bytes and zeroes the entire block. malloc leaves memory uninitialised — reading it before writing is undefined behavior. Rust's vec![0; n] always initializes to zero. On modern operating systems, both calloc and freshly mapped pages from mmap return zeroed memory at nearly zero cost (the OS provides pre-zeroed pages), so calloc is often faster than malloc + memset.

C uses integer return codes to signal success (usually 0) or failure (non-zero). There is no Result type — the "result" value is returned through an output pointer, and the error code is the function's return value. Errors are easy to ignore: divide(5.0, 0.0, &result); with no check on the return value is valid C. Rust forces you to handle Result — ignoring it without let _ = ... produces a compiler warning.

Many C standard-library functions set the global thread-local variable errno on failure. strerror(errno) converts the code to a human-readable message. The global errno is fragile — any subsequent library call may overwrite it. Always copy it immediately after a failure: int saved = errno;. Rust's io::Error carries the OS error code inside the Err variant and never clobbers a global.

Always check malloc's return value. An unchecked malloc is one of the most common C bugs: on memory-exhausted systems, malloc returns NULL, and the subsequent *pointer = value dereferences NULL — a segmentation fault that may be hard to trace back to the allocation site. Rust's default allocator panics (calls alloc_error_handler) on OOM, which at least produces a clear error message and stack trace.

#define is handled by the C preprocessor — a text-substitution step before compilation. #define MAX_BUFFER_SIZE 4096 replaces every occurrence of the identifier with 4096 before the compiler sees it. Unlike Rust's const, a #define has no type, no scope, and no debugger symbol. For type safety, prefer const int MAX_BUFFER_SIZE = 4096; in C17 — the compiler then checks types and the constant appears in backtraces.

C preprocessor macros are text substitution. SQUARE(3+1) without the extra parentheses would expand to 3+1 * 3+1 = 3+3+1 = 7 (wrong due to operator precedence). Always wrap macro parameters and the entire macro expansion in parentheses. Rust's macro_rules! is hygienic — it operates on syntax trees, not raw text, so square!(3 + 1) expands correctly without extra parentheses and cannot introduce identifier hygiene bugs.

C splits code across header files (.h — declarations: prototypes, struct definitions, macros) and implementation files (.c — definitions: actual function bodies). #include "square.h" copies the header text into the source file. Rust's module system uses mod and use — no header/implementation split, no risk of duplicate includes (C uses #pragma once or include guards to prevent that). static on a function limits its visibility to the current translation unit.

C uses preprocessor directives (#ifdef, #ifndef, #if defined()) for conditional compilation. Platform macros like __APPLE__, _WIN32, and __linux__ are predefined by the compiler. Debug builds typically do not define NDEBUG; release builds add -DNDEBUG to strip assertions and debug code. Rust's #[cfg(...)] attributes are type-safe, work on any syntax node, and have a much richer predicate language than C's preprocessor.

fprintf(stderr, ...) is the C equivalent of Rust's eprintln!. Both write to the standard error stream (file descriptor 2). In C, stderr is a FILE* handle predefined by the standard library — you can pass it to any fprintf call. The separation of stdout and stderr allows redirecting them independently: ./program 2>/dev/null discards errors while keeping normal output.

Always fclose every file you fopen — open file handles are a limited OS resource and unflushed buffered data may be lost if the process exits without closing. fwrite(ptr, 1, n, file) writes n bytes starting at ptr. fgets reads one line at a time (including the newline) up to size - 1 characters. Rust's fs::write and fs::read_to_string handle open, write/read, and close atomically, returning a Result.

This example requires interactive input and cannot run in a browser sandbox. Use fgets over scanf("%s", ...) — scanf stops at whitespace and has no buffer-size limit, making it vulnerable to buffer overflows. fflush(stdout) forces the buffered prompt to appear before the program blocks waiting for input. Rust's BufRead::lines() returns an iterator and handles the newline stripping automatically.

Math functions are in <math.h> and require linking with -lm. Rust's math functions are methods on f64/f32 so 2.0_f64.sqrt() and f64::sqrt(2.0) are equivalent. C's pow(x, n) accepts any real exponent; Rust distinguishes powi (integer exponent, faster) and powf (float exponent). Use fabs for absolute value of double; abs from <stdlib.h> is for integers only.

qsort requires a comparator function taking two const void* arguments that must be cast to the actual type. The function returns negative, zero, or positive for less-than, equal, or greater-than. The void* casts bypass the type system — passing the wrong comparator compiles but silently produces wrong results. Rust's .sort() uses the Ord trait — type-safe, no cast required. For integer comparison, the subtraction trick (*a - *b) overflows for large values; use an explicit comparison instead.

memcpy copies n bytes from source to destination; use memmove when the regions may overlap — memcpy has undefined behavior for overlapping memory. memset fills memory byte-by-byte; it works correctly for zero (0x00 == 0 for all numeric types) but is wrong for non-zero values of multi-byte types (memset(arr, 1, ...) does not set integers to 1). Rust's copy_from_slice panics if the slice lengths differ; C's memcpy does not check sizes.