Ruby.CodeCompared.To/C

#include <stdio.h> copies declarations from the Standard I/O header into this file — it tells the compiler that printf exists and how to call it. Without it, the compiler does not know what printf is. Every C program must define a main function: the return type int is the exit code (0 = success, non-zero = failure), and void in the parameter list explicitly declares that main accepts no arguments. printf does not add a newline automatically — \n must be explicit.

C originally only had /* block */ comments in C89 (the version of C formalized in 1989). The // single-line form was added in C99 and is universally supported today. Block comments cannot be nested — a /* inside a block comment does not start a new comment.

C's printf uses format specifiers: %d for integers, %f for floats, %s for strings, %c for characters, %zu for size_t. The width and precision modifiers (%-10s, %.2f) work exactly as in Ruby's sprintf/% operator — because Ruby borrowed the convention from C. fprintf(stream, format, ...) is the generalised form: printf(...) is shorthand for fprintf(stdout, ...). Writing to stderr instead of stdout sends the output to the standard error stream, which is typically unbuffered and continues to appear even when the user redirects stdout to a file.

C is statically typed: every variable must be declared with its type. There is no type inference. The type determines how many bytes are allocated and how the bits are interpreted. bool requires #include <stdbool.h> (C99); without it, use int with 0 for false and any non-zero value for true.

sizeof is a compile-time operator (not a function) that returns the number of bytes a type or variable occupies. size_t is C's standard unsigned integer type for sizes and array indices; its actual width matches the platform's pointer size (32 or 64 bits). The idiom sizeof(array) / sizeof(array[0]) computes the element count — but only works in the same scope where the array was declared on the stack. When an array is passed to a function or assigned to a pointer variable, it decays: the array variable loses its size information and becomes a plain pointer to its first element. After that, sizeof returns the size of the pointer (typically 8 bytes on 64-bit systems), not the size of the original array.

Ruby's Integer is arbitrary-precision — it grows as large as needed. C integers are fixed-width and overflow silently (the value wraps around). The exact sizes of int, long, and long long are platform-dependent, but int is at least 16 bits, long at least 32, and long long exactly 64 on all modern platforms. The example uses an explicit cast: (long long)small + large promotes small from int to long long before adding. Without the cast, the addition would use int arithmetic and overflow on large values.

The _t suffix is a C convention meaning "type" — it marks names that are type aliases (typedefs). Standard library types like size_t, int32_t, and time_t all follow this pattern. <stdint.h> provides exact-width types (int8_t, uint64_t, etc.) guaranteed to be exactly that many bits on every platform. The PRI format macros from <inttypes.h> — like PRId8 and PRIu64 — expand to the correct printf format specifier for each type. They look unusual because the C string literal concatenation feature joins them at compile time: "%" PRId32 "\n" becomes "%d\n" on most platforms but "%ld\n" on others where int32_t is defined as long. This is the portable way to print fixed-width integers.

Ruby's Float is always a 64-bit double. C has both float (32-bit) and double (64-bit). Prefer double for most work; float is only worth the precision loss when memory or SIMD performance is critical. The f suffix on a literal (3.14f) makes it a float constant — without it, all floating-point literals are double. fabs(x) returns the absolute value of a double; use fabsf(x) for float. The Ruby equivalent is x.abs or (-5.0).abs.

Math functions live in <math.h>; on some older systems linking requires -lm (the compiler flag used here). M_PI is not in the C standard but is universally available as an extension — the strictly portable alternative is acos(-1.0). floor and ceil return double, not int. fabs(x) is the absolute value function for double values; it corresponds to Ruby's x.abs. (There is no unary - trick like Ruby's -x.abs in C because C has no operator overloading.)

C casts are explicit: (double)7 / 2 converts 7 to a double before the division. Without the cast, 7 / 2 is integer division producing 3, even if assigned to a double. Casting a float to int always truncates toward zero — it does not round. The names atoi and atof stand for "ASCII to integer" and "ASCII to float" — "ASCII" here means a C string. Despite the f in its name, atof returns a double, not a float; the name predates the separation of float and double in C. strtol ("string to long") and strtod ("string to double") are the modern preferred alternatives because they can detect invalid input via an output pointer parameter, whereas atoi/atof silently return 0 on failure.

C strings are arrays of char terminated by a null byte ('\0'). A char array is mutable; a const char * points to a string literal in read-only memory. There is no negative indexing — greeting[-1] in C is undefined behavior. The null terminator is why the array must be at least strlen + 1 bytes.

C has no + operator for strings. Copying uses strncpy and concatenation uses strncat. The n in these names stands for the maximum number of characters to process; you pass the buffer size to prevent writing past the end of the allocated memory — a "buffer overflow." The unsafe originals strcpy and strcat have no limit and blindly copy until they hit a null terminator, making them a notorious source of security vulnerabilities when the source is longer than the destination. The destination buffer must always be large enough to hold the result plus the null terminator.

The most common C string bug for Rubyists: using == to compare strings. In C, == compares pointer addresses, not content — two strings with identical characters at different memory locations will compare as unequal. Always use strcmp for content comparison. The return value mirrors Ruby's <=>: negative, zero, or positive.

C strings have no methods — all operations are free functions from <string.h> and <ctype.h>. strstr returns a pointer to the first occurrence of the substring, or NULL if not found. Subtracting the original pointer gives the index. toupper takes and returns int, so casting to unsigned char before passing prevents undefined behavior on systems where char is signed.

C arrays are fixed-size and allocated at declaration time — they cannot grow or shrink. There is no negative indexing, no bounds checking, and no .length property — the size must be tracked separately. Accessing beyond the array boundary is undefined behavior: the program may crash, produce garbage, or appear to work while corrupting adjacent memory.

C has no iterators or block syntax — every collection is traversed with an explicit for loop and an index. The C standard does not provide higher-order functions like map, select, or reduce. A const char *[] is an array of pointers, each pointing to a string literal — not an array of character arrays.

C two-dimensional arrays are laid out in row-major order — all elements of row 0 come before row 1 in memory. The outer dimension can be omitted when initializing (int matrix[][3]), but the inner dimensions must be specified for pointer arithmetic to work correctly. Unlike Ruby's array of arrays, this is a single contiguous block of memory.

The logic is identical to Ruby, but the syntax requires parentheses around the condition and braces around the body. C has else if (two words); Ruby uses elsif. In C, any non-zero integer is truthy — there is no dedicated Boolean type in C89, though stdbool.h added bool, true, and false in C99.

C's do-while guarantees the body executes at least once before testing the condition. Ruby lacks this construct — the closest equivalent is loop do ... break if condition end. C also has break to exit a loop and continue to skip to the next iteration (equivalent to Ruby's next).

C's for loop has three clauses: initializer, condition, and post-action. All three are optional — for (;;) is an infinite loop. Variables declared in the initializer (C99+) are scoped to the loop. The index++ post-increment runs after each body execution. This is lower-level than Ruby's iterators but extremely explicit about what the loop does.

The critical difference: C switch falls through to the next case unless stopped by break. Forgetting a break is one of the most common C bugs — execution continues into the next case's code. This fall-through can be intentional (cases 6 and 7 share the same handler above). C switch only works with integer types and constants — no strings, ranges, or patterns.

Every C function must declare its return type. void means no return value. Unlike Ruby, C functions cannot return multiple values — they return exactly one value (or nothing). There are no keyword arguments, no default values, and no splat operators. Every parameter must have an explicit type. Functions must be declared before they are called, or a prototype must appear first.

A prototype declares a function's name, return type, and parameter types so the compiler knows the function's interface before seeing its body. Without a prototype, calling a function defined later in the file is a compile error (or in old C, silently assumes int return). In practice, prototypes go in header files (.h), and definitions go in source files (.c).

Recursion works identically in C, but C has no tail-call optimization guarantee — deep recursion will overflow the stack. The stack frame size is fixed at compile time, not dynamically grown like Ruby's call stack. C compilers may optimize tail calls in practice, but it is not guaranteed by the standard. For deep recursion in C, iterative solutions are safer.

A pointer stores a memory address. The & operator gets the address of a variable. The * operator dereferences a pointer — it reads or writes the value at that address. Ruby's variables are implicitly references, but the mechanics are hidden. In C, every pointer operation is explicit, which makes memory relationships visible and bugs like dangling pointers and null dereferences the programmer's responsibility.

Because C functions can only return one value, pointers are used as output parameters to return multiple results. The caller passes the address of a variable (&x), and the function writes to it through the pointer (*first = ...). This is the C idiom for what Ruby accomplishes with multiple return values. The standard library uses this pattern extensively — for example, scanf takes pointers to the variables it fills.

Adding 1 to a pointer advances it by sizeof(the_pointed_to_type) bytes — not by 1 byte. This is why pointer arithmetic is type-safe: the compiler knows the step size from the pointer's type. Array indexing (numbers[3]) is literally defined as *(numbers + 3) in the C standard. Subtracting two pointers gives the number of elements between them, as a ptrdiff_t.

NULL is C's equivalent of Ruby's nil — a pointer value meaning "points to nothing." Dereferencing a NULL pointer is undefined behavior, typically a segmentation fault. Always check for NULL before using a pointer returned from functions that can fail. malloc, fopen, strstr, and many other standard library functions return NULL on failure.

C has no garbage collector. Every malloc must have a matching free. Forgetting free is a memory leak — the memory stays allocated until the process exits. Calling free twice is undefined behavior (typically a crash or heap corruption). Setting the pointer to NULL after freeing prevents accidental reuse. Use valgrind or address sanitizer (-fsanitize=address) to find leaks and invalid accesses.

calloc(count, size) allocates count * size bytes and zero-initializes every byte. realloc resizes an existing allocation and may move it to a new address, so always assign the result to a new pointer before overwriting the original — if realloc fails, it returns NULL and the original allocation is still valid. This is how dynamic arrays are built in C by hand.

A C struct groups named fields into a single type — it is the closest thing C has to a class, but with no methods or inheritance. Members are accessed with . for struct values or -> for pointers to structs. typedef struct { ... } Name creates an alias so you can write Person instead of struct Person everywhere.

C structs have no methods — functions that operate on them are written as free functions that take the struct as a parameter. By convention, such functions are prefixed with the struct name (e.g., point_distance, point_print). Structs passed by value are copied — large structs should be passed by pointer to avoid the copy overhead. This is the OOP-without-objects pattern that C uses everywhere.

The standard library's qsort sorts any array by calling a user-supplied comparator function. The comparator receives two const void * pointers and must return negative, zero, or positive — the same convention as Ruby's <=>. The -> operator accesses a struct member through a pointer: ptr->field is shorthand for (*ptr).field.

C enums are named integer constants — they have no methods, no string representation, and no type safety. The compiler assigns sequential integer values starting at 0. You can assign specific values to any enumerator. Comparing enum values works correctly because they are just integers, but there is nothing preventing you from assigning an invalid integer to an enum variable.

Bit flags are a classic C pattern for combining multiple boolean options into a single integer. Assign each flag a power of 2 so each occupies a unique bit. Combine with bitwise OR (|) and test with bitwise AND (&). This is how POSIX file permissions, open() flags, and many system call parameters work. Ruby uses the same pattern but it is far more common in C code.

C has no exceptions. Errors are communicated by return values: 0 for success, non-zero for failure (or a specific error code). The actual result is passed back through an output pointer parameter. This means every call site must check the return value — failing to check is a common source of bugs. The compiler does not enforce error checking in C (unlike languages with Result types).

errno is a global integer set by system calls and standard library functions when they fail. strerror(errno) converts it to a human-readable string. perror(prefix) prints "prefix: error message\n" to stderr in one call. Ruby's Errno::ENOENT and friends are Ruby wrappers around the same underlying errno values — they share the same error numbering system as C.

#define is a preprocessor directive — it runs before the compiler and does simple text substitution. Unlike Ruby's constants, #define names have no type and no scope. The modern C alternative is const int MAX_RETRIES = 3;, which is type-checked by the compiler. The preprocessor also handles #include (file inclusion), #ifdef (conditional compilation), and many other directives.

Macro arguments are expanded by text substitution before compilation. This makes them work with any type — MAX(3.14, 2.71) works for doubles without writing a separate function. But each argument is expanded every time it appears in the body, so arguments with side effects (like x++) execute multiple times. Always parenthesize both the whole macro and each argument to avoid operator precedence surprises. Prefer static inline functions when possible.

Conditional compilation lets you include or exclude code at compile time — it's the only way in C to have zero-cost debug logging. The excluded code is not compiled at all, so there is truly no runtime overhead. In practice, you define the flag on the compiler command line (gcc -DDEBUG ...) rather than in source, so you can switch modes without editing code. #ifndef HEADER_H_ guard idiom prevents header files from being included multiple times.

qsort is the standard library's general-purpose sort. The comparator function takes two const void * pointers and must return negative (first comes before second), zero (equal), or positive — the same convention as Ruby's <=>. The subtraction trick (*a - *b) works for integers but can overflow for large values; for robustness, use explicit comparisons instead. bsearch uses the same comparator convention for binary search.

snprintf is the safe version of sprintf — it always null-terminates and never writes more than the specified number of bytes. The older sprintf has no bounds checking and is a common source of buffer overflow vulnerabilities. Calling snprintf(NULL, 0, format, ...) without writing anything returns the number of characters the formatted string would require — useful for allocating exactly the right buffer size.

The type of an expression is determined by the operands, not by what you assign the result to. 7 / 2 is evaluated as integer division (producing 3) before the result is stored in a double. To get floating-point division, at least one operand must be a float or double — either via a literal suffix (7.0) or an explicit cast ((double)total). This is one of the most common silent bugs in C code written by people coming from scripting languages.

C performs zero bounds checking. Reading or writing past an array's end is undefined behavior — the program may crash, silently produce wrong results, or corrupt other variables in memory. Buffer overflows are responsible for a massive fraction of real-world security vulnerabilities. Use -fsanitize=address during development to catch them. Always track the size of every array and validate indices before using them.

Ruby integers are arbitrary-precision and never overflow. C integers are fixed-width: signed integer overflow is undefined behavior — the compiler is allowed to assume it never happens and optimize accordingly, producing results that are nonsensical even if you expect wraparound. Unsigned overflow is well-defined and wraps modulo 2^n. Use -fsanitize=undefined to catch signed overflow bugs during development.

Ruby's String is a rich object with over 100 methods. C strings are null-terminated char arrays with a small handful of library functions in <string.h> and <ctype.h>. There is no built-in split, no gsub, no reverse, no regex. String manipulation that takes one line in Ruby often requires 10–20 lines of C. This is not a weakness — C's simplicity is its strength in systems programming — but Rubyists should set expectations accordingly.

Every byte allocated with malloc must eventually be freed with free. Ruby's garbage collector handles this automatically. In C, functions that return heap-allocated memory must document the ownership contract in their comments — who is responsible for calling free? Using memory after it is freed, freeing the same pointer twice, and forgetting to free are all critical bugs. Use valgrind or compile with -fsanitize=address to detect them.