PHP.CodeCompared.To/C

Every C program is a set of functions, and execution begins at main, which returns an int exit status (0 means success). You must #include <stdio.h> to get printf — nothing is available globally the way PHP's built-ins are. There is no echo; printf writes exactly the bytes you give it, and you spell the newline as \n.

The biggest shift: C is compiled ahead of time, not interpreted per request. A compiler turns your source into a native binary, catching type errors before the program ever runs — the price is a build step and no live reload. There is no interpreter reading the file at runtime, so the program is just machine code by the time it executes.

C has no string interpolation at all — you must use printf format specifiers, and they must match the argument types exactly: %d for int, %s for a string, %f for a double, %.2f to fix two decimals. A mismatch (say %d with a double) is undefined behavior, not a friendly coercion — the compiler's -Wall warnings are your safety net.

In C every variable has a static type fixed when you declare it, and it can only ever hold that type. There is no $ sigil, but you must write the type (int, double, char, a pointer…) in front of the name. Assigning a string to an int is a compile error, not a silent re-type — the dynamic reassignment PHP allows simply does not exist.

C's primitives are low-level: int (typically 32-bit), double (and float), and char — which is really a one-byte integer holding a character code. Note the quoting rule that trips up newcomers: "A" (double quotes) is a string, while 'A' (single quotes) is a single char. Sized types like int32_t and uint8_t live in <stdint.h> when you need exact widths.

C had no boolean type for decades; true/false and the bool alias arrive only when you #include <stdbool.h>, and under the hood they are just the integers 1 and 0. There is no %b format — print a bool with %d to see its numeric value. This integer-ness underlies C's truthiness rules, covered in the Gotchas.

C never promotes types for your convenience. int / int stays an int, truncating 7 / 2 to 3 — unlike PHP, which quietly produces 3.5. To get a real quotient you (double)-cast an operand before dividing. Casts are explicit, deliberate, and exactly as wide as you ask; there is no hidden juggling.

A C string is not an object — it is a plain array of char ending in a hidden \0 (null terminator). That trailing byte is why sizeof is one more than the length, and why every string function must walk to the \0 to find the end. There is no .length property: strlen (from <string.h>) counts characters by scanning for the terminator each time it is called.

PHP's rich string library shrinks to a handful of low-level helpers in <string.h> and <ctype.h>. There is no strtoupper — you loop over the characters and uppercase each one with toupper, mutating the array in place. strstr returns a pointer to the match (or NULL), standing in for str_contains. Everything is manual, and you are responsible for not running past the buffer.

There is no . concatenation operator and no automatic allocation. To build a string you declare a destination buffer big enough to hold the result and fill it with snprintf, which (unlike the dangerous strcat/sprintf) takes the buffer size and refuses to overflow it. Forgetting to size the buffer for the result — including the \0 — is the classic C bug.

A C array has a fixed size baked in at compile time and cannot grow — there is no $numbers[] = 40. Worse, C does not store the length or check bounds: count is computed with the sizeof(array) / sizeof(element) idiom, and indexing past the end is undefined behavior that often "works" silently until it corrupts memory. Growable arrays require manual malloc/realloc, shown in Pointers.

There is no foreach and no iterator protocol — you write an explicit index loop, and you must know the count yourself because the array does not carry its length. The loop counter is size_t (an unsigned type sized for memory offsets), which is the correct type for indices and what sizeof returns.

PHP's single array type is also a hash map; C has no associative array at all. For a handful of entries you scan an array of structs by hand (as here). For real key/value work you implement a hash table or pull in a third-party library — there is no equivalent of just writing ["Alice" => 30]. This absence is one of the largest day-to-day adjustments.

A pointer is a variable that holds a memory address. &value takes the address of a variable; *pointer dereferences it to read or write whatever lives there. PHP hides this machinery completely, so this is genuinely new — but it underpins everything in C: passing data without copying it, dynamic memory, arrays, and strings are all pointers underneath.

C functions always receive copies of their arguments. To let a function modify the caller's variable — PHP's &$value by-reference parameter — you pass the variable's address (&count) and the function writes through the pointer (*value). This explicitness is why so many C functions take pointer arguments: it is the only way to return changes through a parameter.

C has no garbage collector. Memory that must outlive a function or whose size is unknown at compile time comes from the heap via malloc (which returns NULL if it fails — always check), and you must free it yourself. Forgetting to free leaks memory; freeing twice or using memory after freeing corrupts the program. This manual ownership discipline is the heart of systems programming.

When you pass an array to a function it "decays" to a bare pointer to its first element — the size information is lost at the boundary. That is why C functions taking arrays almost always take a companion count parameter: inside sum_all, sizeof(numbers) would give the size of a pointer, not the array. PHP's arrays carry their length everywhere; C's do not.

A pointer that points at nothing is NULL. Dereferencing it (*pointer) does not return a tidy null with a warning as PHP does — it triggers a segmentation fault that kills the process outright. The defensive habit C demands is to check if (pointer != NULL) before every dereference, since the language offers no safety net and no optional-chaining operator.

Conditionals are almost identical — parentheses and braces included — with the one difference that C writes else if as two words rather than PHP's fused elseif. Remember that C's condition is just an integer test: any non-zero value is true, so an accidental assignment if (x = 5) compiles and is always true (a reason compilers warn about it).

C only has the old switch statement, not an expression like PHP 8's match. It compares with loose integer equality, does not return a value, and — critically — falls through from one case into the next unless you write break. Stacking labels (case 2: case 3:) is how you group values, but a forgotten break is a classic bug that match made impossible.

The C-style for and while are exactly what PHP inherited from C, so these read identically. What is missing is the high-level iteration: no foreach, no array_map, no ranges. In C you almost always count an index by hand, which is why the humble for loop does far more of the work than it does in PHP.

C's truthiness is purely numeric: zero is false, every other value is true. There is no notion of an empty string or empty array being falsy — a string literal is a non-NULL pointer, so if ("0") is true, the opposite of PHP where "0" is falsy. Negative numbers are true. This simplicity removes PHP's surprises but means you compare explicitly (strlen(text) == 0) to test emptiness.

A C function declares its return type before the name and types every parameter — the type annotations PHP makes optional are mandatory here. A function must be declared before it is called, so either define it above main (as here) or provide a forward "prototype". There is no overloading: two functions cannot share a name, even with different parameter types.

C has no default parameter values and no named arguments. Every call must pass every argument, in order. The usual workaround is to write a small wrapper function that fills in the default and forwards — verbose compared to PHP's $port = 5432, but explicit. (Variadic functions like printf exist via <stdarg.h>, but they are clumsy and type-unsafe.)

C passes behavior with function pointers — the closest thing to PHP's callable. The declaration syntax int (*operation)(int) reads "pointer to a function taking an int and returning an int". There are no closures: a function pointer captures nothing from its surroundings, so any extra data a callback needs must be threaded through explicitly (often as a void * context argument).

A struct groups named fields — the data half of a PHP class, with no methods, no constructor, and no visibility. You create one as a plain value (no new, no heap), and access fields with a dot. Note you must write struct Point as the full type name unless you typedef it (shown next). Behavior lives in separate functions that take the struct, not inside it.

Since structs have no methods, behavior is a free function whose first parameter is a pointer to the struct — exactly the explicit $this that PHP passes for you. The -> operator is shorthand for "dereference a struct pointer and access a field": account->balance means (*account).balance. You may recognize -> from PHP, but here it specifically signals a pointer, while . is for a direct struct value.

typedef creates an alias for a type, most often so you can write Coordinate instead of struct Coordinate at every use. It is purely a naming convenience — there is no immutability, no constructor, no validation like PHP's readonly promoted properties. C gives you the bag of fields and nothing more; any invariants are yours to enforce by convention.

C does have enums, but they are far weaker than PHP 8's: each case is simply a named int constant (ACTIVE = 0, PENDING = 1, …), with no string backing, no methods, and no type safety — an enum Status variable will silently accept any integer. There is no ->value or ::from(); the case is its number, which is why enums often pair with a lookup array to recover a name.

Because a C enum value is only an integer, there is no built-in way to get back its name — printf("%d", suit) shows the number. The idiom is a parallel string array indexed by the enum, so names[suit] yields the label. You must keep that array in lockstep with the enum by hand, a chore PHP's backed enums eliminate entirely.

C has no exceptions — no throw, try, or catch. The universal convention is that a function returns a status code (0 for success, non-zero for an error) and delivers its real result through an out-parameter pointer. The caller must check the return value every single time; there is no automatic propagation, so an unchecked error simply goes unnoticed.

Many standard-library calls report why they failed through errno, a global error number set as a side effect. After a failing call you read it immediately and translate it to text with strerror (this prints "No such file or directory"). It is a fragile mechanism — any intervening call can overwrite errno — and a world away from PHP's structured exception objects.

The integer main returns is the process exit status that the shell and other programs inspect — 0 for success, non-zero for failure — the same contract as PHP's exit($status). Diagnostics go to standard error via fprintf(stderr, ...) so they stay separate from real output on stdout. Both examples take the invalid-port path and exit with status 1.

C has two notions of "constant". #define is a preprocessor macro — the compiler literally replaces MAX_USERS with 100 as text before compilation, with no type and no scope. const int is a true typed, scoped constant and is usually the better choice. PHP's define() resembles the macro, but C's runs at compile time, not runtime.

Function-like macros take arguments but are still pure text substitution, which is powerful and dangerous: without the defensive parentheses, SQUARE(2 + 3) would expand to 2 + 3 * 2 + 3 = 11, not 25. They also evaluate arguments more than once (avoid SQUARE(i++)). Modern C code prefers real functions — the compiler inlines small ones anyway — and reserves macros for things functions cannot do.

C splits code across files differently from PHP's require. A header (.h) declares what exists — function prototypes and types — and a .c file provides the implementation. Other files #include the header to learn the interface, then the linker stitches the compiled pieces together. There are no namespaces, so names are global; the convention is to prefix them (mathutils_square) to avoid collisions. This multi-file example cannot run in the single-file sandbox.

Math splits across headers: integer abs is in <stdlib.h> while pow, sqrt, and friends are in <math.h> — and on many systems you must link the math library with -lm. There is no variadic max that takes any number of arguments; you compare with the ternary operator or write a macro. Note pow always returns a double, even for integer inputs.

qsort is the standard sort, but it is far more manual than usort. Because C has no generics, it works on raw memory: you hand it the array, the element count, the size of each element, and a comparator that receives const void * pointers it must cast back to the real type. The (left > right) - (left < right) trick yields the same -1/0/1 as PHP's spaceship without risking integer overflow.

C's rand must be seeded once with srand (usually from time(NULL)) or it produces the same sequence every run — PHP seeds for you. Reducing to a range with % 6 is slightly biased and rand is not suitable for security; PHP's random_int is unbiased and cryptographically secure out of the box. For real randomness in C you reach for OS facilities like getrandom.

A dangerous trap: in C a string is a pointer, so a == b compares the two addresses, not the characters — almost always not what you want, and it compiles without complaint. You must use strcmp, which returns 0 when the contents are equal (note: 0, not a truthy value). PHP's == compares string contents; C's does not.

Unlike PHP, where 7 / 2 promotes to 3.5, in C dividing two ints gives an int — 3, the fractional part discarded. Make an operand a double to get a real quotient. C truncates toward zero, so -7 / 2 is -3 (matching PHP's intdiv). Mixing this up with a %d/%f format mismatch compounds the surprise, so watch both.

C integers are fixed-width and do not grow. An int tops out at INT_MAX (about 2.1 billion); pushing a signed type past its limit is undefined behavior, while unsigned types wrap around cleanly (255 + 1 becomes 0 in a byte). PHP shields you by widening its 64-bit ints to floats on overflow — C does not, so choosing the right-width type and watching for overflow is on you.

C does not zero-initialize local variables. A declaration like int total; leaves whatever bytes happened to be on the stack — reading it is undefined behavior, and the value is unpredictable. Always initialize at declaration (int total = 0;). PHP's habit of treating an unset variable as null/0 is exactly the assumption that produces baffling bugs in C.