C.CodeCompared.To/PHP

echo is a language construct rather than a function, so it takes no parentheses, returns nothing, and adds no newline — which makes it closer to fputs(stdout, …) than to puts. The closing ?> tag is deliberately left off every file on this page: a stray blank line after it would be sent to the client and break a header, so omitting it is the convention everywhere.

The two columns print the same three lines. One difference shows up in the output: C pads the exponent to two digits, so %e gives 1.234500e+03 where PHP gives 1.234500e+3. The rest are small and worth knowing: PHP adds %b for binary and %'x10d for an arbitrary pad character, drops the length modifiers (%ld, %zu) because there is only one integer type, and — crucially — printf is a real function with a variable argument list that it can actually count, so passing too few arguments is an ArgumentCountError rather than a read of whatever was on the stack.

The check that does happen is worth the space it takes: with declare(strict_types=1) at the top of the file, a declared parameter type is enforced at the call site and a mismatch throws immediately, naming the caller. Without that line PHP coerces instead — "3" would become 3 — so the declaration is worth roughly nothing. Put it at the top of every file.

The <?= … ?> form is shorthand for <?php echo … ?>, and one newline immediately after a closing tag is swallowed so that templates do not fill up with blank lines — which is why the example has a blank line after the <?= $count ?>: the first newline is eaten and the second is the one that reaches the output. This is a genuinely different execution model from anything in C: the program is a document with holes in it, and the holes are evaluated in order.

The $ also makes interpolation possible: "$count items" substitutes the variable inside a double-quoted string, which is why the C column needs printf and the PHP column does not. Single quotes turn interpolation off, so '$count' is the two characters. There is one namespace for variables and a separate one for functions, so $count and count() never collide.

The check happens on every call, so it costs something — but it turns a class of silent coercions into an exception at the boundary, which is the nearest thing to a compiler PHP has. Union types (int|string), nullable types (?int), and never are all spellable. Without strict_types, that doubled("21") would quietly succeed and return 42.

Constants have no $, which is how the parser tells them from variables, and they are not interpolated into strings. The enum is the closer match to C’s: it is a real type, so a function can declare it as a parameter type and nothing else will be accepted — where a C enum is an int in a hat and any integer fits in it.

The C column’s output order is not guaranteed, incidentally — the order in which printf’s arguments are evaluated is unspecified, so this exact program may print 1 2 3 or 3 2 1 depending on the compiler. PHP specifies left-to-right evaluation, so its column always prints 1 2 3. That is a small example of a large theme: several things C leaves to the implementation, PHP simply defines.

Variable variables exist, they work, and they are almost always the wrong answer — an array is clearer, faster and greppable, which is why the second half of the column is what you will actually see in a codebase. The reason to know the feature is that it explains why PHP can do things C cannot: names are looked up in a hash table while the program runs, which is the same mechanism behind $$name, $object->$property and $function().

The promotion keeps the magnitude and loses the exactness — a float has 53 bits of significand, so past 2⁵³ consecutive integers stop being distinguishable, which is what the last line demonstrates. It is safer than C’s undefined behavior and worse than C’s defined unsigned wrap, and the practical rule is the same one you already use: if the value can be large, check before you multiply. intdiv throws on overflow rather than promoting, which is the one place PHP prefers an error.

The signs agree: both truncate toward zero, so -17 / 5 is −3 and -17 % 5 is −2 in each column. Division by zero is where they part company — undefined behavior in C, typically a SIGFPE, and a catchable DivisionByZeroError here. Note also that % casts its operands to int first, so 7.5 % 2 is 1, not 1.5; fmod is the floating-point remainder.

The C column’s last line prints 0, which is correct and almost never what the author wanted: -1 converts to a very large unsigned value before the comparison. PHP has no way to write that bug. The cost is at 64 bits: unpack("J", …) on a value above 2⁶³ comes back negative, and there is nothing wider to put it in short of a string.

Both columns print a trillion, but the C one has to say 1L to get there: shifting an int by 40 is undefined behavior, and this program printed 177873260 before the L was added. PHP has no narrower integer to fall off, so its shift is always the 64-bit one. Shifting by a negative amount throws ArithmeticError and shifting by 64 or more gives zero, both of which are also undefined behavior in C. The %b conversion in the last line has no C counterpart and saves the hand-rolled bit extraction the other column needs.

The C column stops at the zero byte and reports 4; PHP reports 9, because the length was stored when the string was built. This is what "binary-safe" means in the PHP manual, a phrase that appears on nearly every string function: it will not stop early at a zero byte. The practical consequence is that file_get_contents on a JPEG gives you the whole file in a string, and every byte of it is addressable.

It is a byte offset, not a character offset, so writing into a multi-byte character corrupts it exactly as it would in C. The difference from C is that the string grows rather than smashing whatever came after it, and that reading past the end gives a warning and an empty string rather than undefined behavior. Negative offsets count from the end, which C has no spelling for at all.

The one trap in the family is strpos: it returns false when the needle is absent and 0 when the needle is at the start, and false == 0 is true. Always compare with !== false, or use str_contains, which was added for exactly this reason. Note also that these are all byte-oriented, so strtoupper only handles ASCII — the accent-aware version lives in the mbstring extension.

The indentation of the closing label is stripped from every line, so the block can sit at the indentation of the code around it without that whitespace ending up in the output. The <<<'LABEL' variant, with the label quoted, turns interpolation off and is the equivalent of a raw string — useful when the text contains $.

Under the hood this is a hash table with a separate ordered list of buckets, so iteration order is insertion order, not key order — a guarantee C’s hand-rolled tables usually do not make. The cost is that a "list" of a million integers is a hash table of a million integers, roughly an order of magnitude more memory than int[1000000]. When that matters, SplFixedArray in the stdlib section is the real array.

The copy is lazy — the engine shares the buffer and clones it only when one side writes, so passing a large array to a function that only reads it costs nothing. The & in the parameter list is the closest thing PHP has to the pointer you would pass in C, and it is declared once at the function rather than at every call. Objects are the exception: a variable holding an object holds a handle, so objects alias exactly as C pointers do.

The keys assigned by [] are the next unused integer, so removing an element from the middle with unset leaves a gap and the array stops being a clean list. array_values renumbers it. That distinction matters when the array is encoded as JSON: a gapped array becomes a JSON object with numeric keys rather than an array, which is a bug that reliably surfaces at the far end of an API.

array_filter preserves the original keys, so the result is a gapped array — which is why array_map here still works but implode on a filtered result can surprise you. The argument order is famously inconsistent across the family (array_map(callback, array) against array_filter(array, callback)), a wart left over from the library growing organically in C.

The <=> operator is the comparator written as punctuation: it returns −1, 0 or 1, and it handles numbers, strings and arrays. Note that usort sorts in place and returns a boolean, like qsort returning nothing — the value you want is in the variable you passed, which is why it takes its array by reference. sort also discards the keys; asort keeps them.

The & is declared once, at the function, and the call site looks like an ordinary call — which is the opposite of C#’s choice and the same as C++’s. That means you cannot tell from a call whether an argument might be modified, and it is why the modern style is to return a value or a tuple instead, and to reserve & for the places the standard library already uses it (sort, preg_match, array_push).

The leading count parameter is gone because the array knows its length, and int ...$values type-checks every element — sumOf(1, "two") throws rather than reading a pointer as an integer. Named arguments are the other half of the story: they let a caller skip past a default without repeating it, which is what the three separate C wrapper functions were for.

PHP is unusual here: a function () use ($x) closure captures only the names in the use list, and by value unless you write &. The shorter fn() => arrow form captures everything it references, automatically and by value, which is why it is now the common spelling — and why it is limited to a single expression.

The strtoupper(...) spelling — a call with a literal three dots — makes a closure from an existing function without naming it in a string, which means the name is checked when the file compiles instead of when the call happens. That is the modern replacement for "strtoupper" and [$object, "method"], both of which still work and both of which fail only at the moment of the call.

The falsy list is: false, 0, 0.0, "", "0", the empty array, and null. Every other value is truthy, including the string "0.0" and the array [0]. Note that the C column’s last line prints true: a char * to an empty string is a non-null pointer. Both languages have a trap here; they are just different traps.

PHP 8 fixed the worst case: "abc" == 0 used to be true, because the string was converted to a number and non-numeric strings became zero. Now the number is converted to a string instead when the other side is non-numeric. Two numeric-looking strings are still compared as numbers, which is how "1e2" == "100" comes out true — so use === unless you have a specific reason not to.

Both columns print 111 for the fallthrough, because the construct is the same one. match is the improvement: it is an expression so it can be returned or assigned directly, it uses === so "1" does not match 1, and an unmatched value throws rather than silently doing nothing — which is the check C’s -Wswitch only gives you for enums.

That unset($value) is not superstition. After a by-reference foreach, $value is still a reference to the last element, so a second foreach using the same variable name overwrites that element on every iteration — a bug that produces a plausible-looking array with its last two entries wrong. It is the closest thing PHP has to a dangling pointer, and unsetting the variable is the fix.

The -> is the same arrow you use on a struct pointer, which is not a coincidence — PHP borrowed it. Constructor property promotion, the private float $width in the parameter list, declares the property and assigns it in one place; before PHP 8 that took three lines per field. Note that objects, unlike arrays, are handles: assigning $other = $shape gives you a second name for one rectangle.

A class that says implements Shape and omits area fails to compile that file, which is the check the C column has no way to make — nothing stops you leaving a function pointer null. The void * casts are gone too, and with them the ability to pair the circle’s table with the square’s data. Both shapes can now sit in one array, which the C version cannot manage without a common header struct.

The C column’s last two lines are the point: article.status = 99 compiles and runs, because an enum is an int and any int fits. Status here is a type — a parameter declared Status accepts nothing else, Status::from(99) throws, and the enum can carry methods. That combination is what C programmers most often reach for a lookup table to fake.

PHP’s own conversions mostly do not throw: (int) "bad" is 0, and a bad numeric string in arithmetic raises a warning rather than an error. So arriving from C you get exceptions where your code raises them and quiet wrong values everywhere else, which is why filter_var and explicit validation at the boundary matter more here than in a language that checks types for you.

The output proves the ordering: finally runs after the return value has been computed but before the function actually returns. That makes it the right home for closing a handle or releasing a lock, and the wrong home for a return of its own — a return inside finally silently replaces the one on its way out, including replacing an in-flight exception.

Catch Exception for conditions you expect and Error only at the top of the program, to log a bug before exiting — swallowing a TypeError in the middle of a request usually just moves the failure somewhere less informative. Throwable catches both and is what a framework’s outermost handler uses.

The destructor runs at a moment you can predict, which is why __destruct is a workable place to close a file handle in a way that finalize in a garbage-collected language is not. What reference counting cannot free on its own is a cycle — two objects pointing at each other keep each other alive — so PHP also runs a cycle collector periodically, and gc_collect_cycles() forces it.

The reported memory jumps at the write, not at the assignment, which is the whole mechanism in one measurement. The practical consequence for a C programmer: passing a big array to a function that only reads it is free, and there is no reason to reach for & to avoid a copy. Add & only when the function is meant to modify the caller’s array.

The two columns produce the same six bytes. The C column also prints sizeof(struct Record) — 8, not 6, because the compiler padded length onto a four-byte boundary — which is exactly why fwrite(&record, sizeof record, 1, file) is not a wire format. The format letters are worth memorizing: n/N are big-endian 16 and 32, v/V little-endian, J/P the 64-bit pair, and C a single byte.

ord takes the first byte of the string and returns 0–255, so it is (unsigned char) rather than (char) — there is no sign question to worry about. str_split with no second argument gives one-byte pieces, which is the byte-array view of a string; unpack("C*", $text) gives the same thing as integers, and is faster for a large buffer.

The last line is the PHP spelling of the classic C endianness probe, and it works the same way: encode 1 in native order and compare it with 1 encoded little-endian. Use N and V for anything that leaves the process; L and its siblings are for talking to native code on the same machine, which is what the FFI section is about.

fgets needs no buffer and no size, because the string it returns is allocated for you — and it returns false at end of file, which is why the loop compares with !== false rather than testing truthiness (a line containing just "0" would end the loop otherwise). file_get_contents reads the whole file into one binary-safe string, which is the operation C makes you write fseek/ftell/malloc/fread for.

The two columns print the same seven lines, but the pi row needed care: M_PI is a POSIX extension rather than ISO C, so under -std=c17 the C column does not compile with it and the constant has to be written out — while PHP defines M_PI unconditionally. ** is available as an operator for pow, and PHP_FLOAT_EPSILON is DBL_EPSILON — the comparison advice is identical, because the representation is identical. One addition with no C counterpart: random_int is a cryptographically secure integer generator, which saves reaching for /dev/urandom by hand.

The bounds check is the part a plain array does not give you: $array[9] on an ordinary PHP array is a warning and null, while this throws. The memory saving is roughly four to five times for a large list of integers, which is why it shows up in numeric code and almost nowhere else — for ordinary work the hash-table array is what everything else in the library expects.

The / characters around the pattern are delimiters, not part of it, and a trailing letter after the closing one is a flag — i for case-insensitive, u for UTF-8 mode. The matches arrive as an ordinary array with group 0 being the whole match, which is the same numbering as regmatch_t, with the offset arithmetic done for you. Named groups ((?<year>\d{4})) show up as string keys in the same array.

The declarations are parsed by PHP’s own C parser, so no header file and no compilation step are involved — but nothing checks them against the library, and a wrong parameter width corrupts the stack rather than raising an error. FFI is disabled by default in production for exactly that reason. The genuinely supported path for shipping C to PHP is still a Zend extension, which is a C file against PHP’s own API, compiled with phpize.

A string in that union carries its length, which is why strlen is O(1) and why zero bytes are ordinary data. Reference counting lives in the same header, which is why unset can free a value immediately. And an array is a hash table of these tagged values, which is why one array can hold mixed types and why it costs several times what a C array of the same length would.