C.CodeCompared.To/Fortran

The '(a)' is a format specification meaning "one character string", and it is what keeps the output free of the leading blank that print *, would add. The program name after program and end program is documentation — it does not have to be main and nothing links against it. Falling off the end returns a zero exit status; stop 3 is how you return something else.

The implicit-typing rule is why i, j, k, m and n became the conventional loop-counter names — they were the letters that defaulted to integer. It is also why implicit none is the first line of every modern Fortran program and of every example on this page: it turns the language’s oldest misfeature off. There is no way to enable it globally; you write it in every program unit and every module.

The descriptors read straightforwardly once you know the letters: a is character, i integer, f fixed-point real, es scientific, 1x one blank. Widths come after the letter, so i5 is a five-wide integer and i0 means "exactly as wide as it needs to be" — the closest thing to %d. Two things have no counterpart: the a descriptor always right-justifies, so there is no %-10s to be had — you pad with trim and blanks instead — and the exponent letter comes out capital, so 1.234E+03 where C prints 1.234e+03. Note also the & at the end of the continued line: Fortran statements end at the newline unless you say otherwise.

The count excludes the program name, which argc includes — so the two columns print the same number only because the C one subtracts one. get_command_argument writes into a buffer you sized and reports the true length separately, which is the same discipline as snprintf; asking for argument zero gives the program name.

The suffix on a literal — 5000000000_int64 — is the counterpart of C’s LL, and it matters for the same reason: without it the literal is default kind and may not fit. storage_size reports bits rather than bytes, which is why the second line divides by eight; there is no sizeof, because a Fortran program is not expected to know how anything is laid out.

The C column’s last line prints 0, which is correct and almost never what the author meant. Fortran has no way to write that bug, at the cost of needing a wider type whenever a value would only fit unsigned. Note also that overflow is not defined here either — it is simply not specified, exactly as in C, and gfortran will happily fold it away. huge(x) is the largest value of x’s kind, which is INT_MAX spelled as a question about a variable.

The operators are different too: .and., .or., .not., .eqv. and .neqv. take logicals, while <, == and friends produce them. merge(a, b, mask) is the ternary operator, and it works element-wise on arrays as well — which is a capability C’s ?: has no equivalent of.

The one addition is the pair mod and modulo: mod takes the sign of the numerator and matches C’s % exactly, while modulo takes the sign of the divisor and gives 3 for modulo(-17, 5). Having both spelled separately is a small kindness — in C you write the adjustment by hand every time you want the second one.

Round brackets are used for both subscripting and calling, which takes some getting used to — numbers(1) and sin(x) look identical, and the compiler tells them apart from the declarations. The arbitrary lower bound removes a whole category of off-by-one arithmetic: no subtracting a base, and lbound/ubound report what the array actually is.

Both columns hold the same matrix — rows 1 2 3 and 4 5 6 — and both walk it in the order their own memory layout prefers, and they print different sequences: 1 2 3 4 5 6 against 1 4 2 5 3 6. Each column’s two lines agree with each other, which is the proof that each really is reading memory in order. The practical consequence is the loop nesting: the innermost loop should vary the last subscript in C and the first in Fortran, and getting it backwards walks memory with a stride instead of sequentially — on a large matrix that is the difference between running at cache speed and not.

The colon in values(:) is what makes it assumed-shape, and it requires an explicit interface — which is why the procedure lives after contains inside the program, or in a module. The older style, values(count) with the length passed separately, is exactly the C convention and still works; it is what you will see in code written before 1990.

Every mathematical intrinsic is elemental: sqrt of an array is an array of square roots, with no loop and no map. Because the compiler knows the whole operation, it can vectorize it, fuse the expression, and skip the temporary — which is a large part of why numerical code is still written in this language. The one rule is shape conformance: adding a 4-element array to a 5-element one is a compile error, not a buffer overrun.

A section is a first-class value: it can be passed to a procedure, assigned to, or used in an expression, and the compiler either passes a descriptor or makes a temporary copy as needed. That last assignment — setting three elements to one scalar — is broadcasting, and it is what C spells as a for loop or a memset that only works for zero.

The mask= argument is the part with no concise C equivalent: it takes a logical array — here produced by comparing the whole array against a scalar — and reduces only where it is true. maxloc returns a position, which is 1-based like every other subscript, so the C column has to add one to agree. count, minloc, product, any and all round out the family.

The reshape literals are written in column order, which is why they look shuffled next to the C initializers holding the same matrices — that is the storage-order difference from two rows back, showing up in the source. transpose, dot_product and matmul are the three that matter; anything larger goes to BLAS, and the compiler will often call it for you.

The two lengths are the point: len is the declared size and never changes, while len_trim is the length ignoring trailing blanks — the closest thing to strlen. That padding is why trim() appears in almost every line of real Fortran that prints a string, and why comparing two character values of different lengths pads the shorter one rather than reporting a difference.

index returns a 1-based position and 0 when the substring is absent, which is cleaner than strstr’s pointer-or-NULL — and it is why the two columns print 4 and 5 for the same match. Note that there is no uppercase intrinsic — the helper above is the standard way, and it is the same loop you would write in C, because iachar and achar are exactly the cast to and from a character code. The character(len=len(input)) declaration on the result is an automatic length: the returned string is sized from an argument.

No malloc, no length arithmetic, no free — the assignment allocates, reallocates on the next assignment, and deallocates at end of scope. This is the modern replacement for the fixed character(len=256) buffer that older code passes everywhere, and it is worth reaching for whenever the length is not genuinely fixed.

There is no & at the call site and no * in the body, which is convenient and also means you cannot tell from a call whether an argument will be modified — that is what intent, in the next row, is for. The historical consequence to be aware of: passing a literal to a procedure that modifies it used to corrupt the constant, which is why compilers now pass a copy for expressions and literals.

intent(out) is the one with no C counterpart, and it is not just documentation: the compiler may skip copying the argument in, and it will warn if a path through the procedure leaves it unset. Combined with pure, which forbids side effects entirely, these are the declarations that let a Fortran compiler reorder and parallelize loops that a C compiler must assume might alias.

The result is delivered by assigning to the function’s own name, which is unusual and worth reading twice; function area(...) result(computed) lets you name it something else, and is the common style. The split matters because a function call cannot be a statement — so the C habit of calling something for its side effect and dropping the result has no spelling, and a procedure that does work is declared as the subroutine it is.

A missing optional argument is genuinely absent rather than defaulted, which is why present() exists — there is no way to declare a default value, so the "what to do when it is missing" logic lives in the body. Keyword arguments work for every procedure with an explicit interface, and they are what makes the intrinsic library readable: sum(numbers, mask=...) and reshape(source, shape, pad=...) both rely on them.

The same procedure now takes a scalar, a vector, or a three-dimensional array, with no overloading and no template. elemental implies pure — no side effects, no I/O, all arguments intent(in) — which is precisely the contract that lets the compiler evaluate the elements in any order or in parallel. Every mathematical intrinsic in the language is declared this way.

Recursion needs no keyword since Fortran 2018 — recursive is the default now and the word is optional, having been required before. The interface point is the important one: a procedure in a module is checked at every call site in every file that uses it, which is the checking C’s header files only approximate. A procedure with no interface at all — an external one, declared the old way — is trusted exactly as a C prototype is.

You can write deallocate explicitly when you want the memory back sooner, and allocated() asks whether it currently holds anything — which is the null check, made into a question about the variable rather than about a pointer. An allocate that fails aborts the program unless you supply stat=, which is the same choice C makes you handle at every call.

The scratch array is typically placed on the stack, which makes it fast and also means a very large one can overflow it — the same trade as alloca, with the same advice: use allocatable above a few tens of kilobytes. The whole-array assignment scratch = values * 2.0 is doing the loop as well, which is why the Fortran body is four lines against the C column’s dozen.

The => operator is pointer assignment and = is ordinary assignment through the pointer, which is a distinction C makes with * and its absence. Because a pointer can be associated with an array section, it carries a stride as well as an address — so view => numbers(1:5:2) is a strided view, which C can only express as an index calculation. Pointers are rare in modern Fortran; allocatable covers most of what C uses pointers for.

The private line makes everything hidden by default and public lists the exceptions, which is the opposite of C’s default and the same effect as marking every internal function static. use geometry, only: circle_area imports one name — worth doing, because a bare use brings in everything and two modules exporting the same name collide. Both program units can live in one file, as here, or in separate ones compiled in dependency order.

The character(len=*) on a parameter means "as long as the value", so the length is inferred rather than counted by hand. Because a parameter is a value rather than text, it can be used where a constant expression is required — including as an array bound — and the compiler folds it away exactly as it would a macro, with none of the double-evaluation hazards macros bring.

The default initializers mean origin is (0.0, 0.0) without being assigned, which C can only manage with an explicit = {0}. point(3.0, 4.0) is the structure constructor, and it accepts keywords too — point(y=4.0, x=3.0). The one thing to know before interop: the standard does not fix the field order in memory unless the type is declared bind(c), which the last section covers.

Note class(rectangle) rather than type(rectangle) on the receiver: class means "this type or anything extending it", which is what makes the procedure inheritable and overridable. That is the whole object system — extends for inheritance, deferred for an abstract method — and it is exactly what the C column builds by hand out of a struct of function pointers.

The two columns print different first lines on purpose: C runs five times because the bound is re-read, Fortran three times because the trip count was fixed at entry. That fixed count is what allows the loop to be parallelized or unrolled without analysis, and it also means modifying the loop variable inside the body is forbidden rather than merely unwise. exit and cycle are break and continue, and both can name a labelled loop to leave a nested one.

The range form case (3:5) and the open forms case (:0) and case (10:) are what C makes you spell as a chain of ifs or a run of empty labels. The selector may be an integer, a character or a logical, but not a real — because equality on floating point is not something the language wants to encourage.

The mask values < 0.0 is itself an array — of logical, the same shape as values — which is why it can be counted, combined with .and., or handed to sum as its mask= argument. merge is the expression form and works anywhere a value is wanted, which makes it the element-wise ?: that C has no equivalent of.

The aliasing question that restrict answers barely arises here — Fortran’s argument rules already forbid a procedure from being passed the same array twice in a way that lets it alias, which is a large part of why Fortran has historically outrun C on numerical loops. do concurrent adds the loop-level promise, and with the right flag a compiler will offload it to threads or a GPU. The last line is the reminder that most such loops did not need to be written at all.

The argument is only there to say which kind you are asking about — its value is ignored, so huge(0_int32) works as well as a variable. That design is what makes generic numerical code possible: a procedure written for real(wp) can use epsilon(x) and get the right answer for whatever wp turns out to be, where the C equivalent needs a different macro per type.

The Fortran column constructs the values with ieee_value rather than by dividing by zero, because dividing by zero is not required to produce infinity — a conforming implementation may stop the program instead, and the ieee_arithmetic module is how you turn that behavior on and off. Note the first line inverts the C question: there is ieee_is_finite rather than an "is infinite", which is the same information the other way up.

The leading blank on each line is not an accident — it is the historical carriage-control character, and it is why every other example on this page uses an explicit format. What list-directed output does give you is types you never have to name and arrays that print themselves, which is exactly what you want at three in the morning and never what you want in a file somebody else will parse.

Note that the internal read takes a character variable, never a literal — read("42", …) is rejected, because the unit is where the data comes from and a literal cannot be one. The buffer cannot overflow, because a write that does not fit is an error rather than a silent overrun — which is snprintf’s truncation made into a diagnosis. The trim in the print is the blank-padding tax from the strings section: line is 64 characters no matter how few were written. Internal reads are how you parse a number out of text without sscanf’s format-string hazards.

newunit= asks the runtime for a free unit number, which is what saves you from the older practice of picking one and hoping — units 5 and 6 are standard input and output by convention, and colliding with them is an old and reliable bug. iostat= is the pattern to internalize: it turns what would otherwise abort the program into a status you test, and a negative value specifically means end of file.

The two columns print the same five numbers, which is the guarantee doing its job. Two kinds are worth singling out: c_char for text and c_ptr, which is an opaque handle rather than something you can dereference — turning one into a usable Fortran array takes c_f_pointer, two rows down. A kind that the platform cannot provide comes back negative, so c_long_double < 0 is how you find out it is unavailable.

Three details do all the work. value on the abs argument is essential — Fortran passes by reference by default, and C expects the integer itself, so without it you would be handing abs a pointer. c_null_char is appended by hand because a C string is terminated and a Fortran one is not. And import is needed because an interface block does not inherit the enclosing scope’s use.

Both columns report 24 bytes: four for kind, four of padding so weight lands on an eight-byte boundary, eight for weight, four for flags and four more of tail padding. Getting the same number from both sides is the point — without bind(c) the Fortran compiler is free to lay it out differently and nothing would tell you. Only the C column can print the individual offsets: there is no offsetof in Fortran, because a program is not supposed to know where a field sits, and the total size is the whole of what you can check from this side. A bind(c) type may not have allocatable or pointer components, default initializers, or type-bound procedures.

Once c_f_pointer has run, block is an ordinary Fortran array: sum works on it, so do sections and whole-array assignment, and it is 1-based like everything else. It does not own the memory — the c_free at the end is still yours to write, and this is the one place on the page where the C ownership discipline comes back in full. c_loc goes the other way, handing a Fortran target’s address to C.

Both columns print the same two rows, and the C one had to do the index arithmetic by hand to get there — which is exactly what a real interop layer does. The three practical rules: declare the C side as a flat array and index it yourself, or as double a[3][2] with the subscripts reversed; never pass a non-contiguous Fortran array section to C without letting the compiler make a contiguous copy; and remember that C’s a[j][i] is not a transpose, it is the same matrix read correctly.