Pascal.CodeCompared.To/C

The structural differences are immediately visible: Pascal wraps code in program Name; begin ... end.; C wraps it in int main(void) { ... }. Pascal's writeln adds a newline automatically; C's printf needs an explicit \n. C requires #include <stdio.h> to use printf.

Both languages compile directly to native machine code. Free Pascal's single-file workflow is nearly identical to GCC's: compile to binary, run binary. C's -Wall -Wextra flags enable warnings that catch many Pascal-style assumptions (implicit conversions, missing return statements). The -lm flag links the math library for sqrt, sin, etc.

C's printf format specifiers (%s, %d, %.2f) map directly to Pascal's Format function specifiers. Pascal's bare writeln(a, b, c) concatenates multiple arguments; C requires a format string with one specifier per value. The \n in C strings is a literal escape — Pascal's writeln adds it automatically.

Pascal declares variables in a var block before begin; C declares them at the point of use (since C99) or at the top of a block. The assignment operator is = in C, not Pascal's :=. C had no boolean type until C99's <stdbool.h> — and bool is really _Bool underneath.

C's plain int, long, etc. have implementation-defined sizes — notoriously a source of portability bugs. The <stdint.h> header (C99) provides exact-width types like int32_t and uint64_t, which map directly to Pascal's integer/cardinal/int64. Always prefer int32_t-style names in new C code.

C has two mechanisms for constants: the preprocessor #define (text substitution, no type checking) and const variables (typed, scope-respecting). Use const over #define in modern C — the compiler gives better error messages and the debugger can see the name. Pascal's typed constants (const x: integer = 5) correspond to C's const variables.

C's typedef creates a new name for an existing type, like Pascal's type AliasName = BaseType. C has no subrange types — declaring age_t as an alias for int adds no bounds checking. In Pascal, assigning 200 to a 0..150 subrange raises a range-check error at runtime (when compiled with {$R+}).

C has no string type — strings are null-terminated char arrays. You must allocate the buffer (either on the stack with a fixed size or on the heap with malloc), track its capacity, and terminate it with '\0'. snprintf writes at most n-1 characters, always null-terminating the result — always use it over sprintf.

C's <string.h> provides strlen, strstr, strcpy, strcat, and strcmp, but many of Pascal's SysUtils conveniences (Trim, UpperCase, Format) have no C equivalent — you write them yourself or use a library. strstr returns a pointer into the string, not a 1-based position.

In C, a == b compares pointers, not string contents — it is almost always wrong for string comparison. Use strcmp from <string.h>: it returns 0 for equal, negative if the first string is lexicographically less, positive if greater. This is one of the most common C gotchas for programmers coming from any other language.

Pascal arrays can start at any index; C arrays always start at 0. More critically: Pascal's range-check compiler option ({$R+}) raises an exception on out-of-bounds access; C performs no bounds checking at all. An out-of-bounds access in C is undefined behaviour — it may silently corrupt memory, crash later, or appear to work. This is one of the most dangerous differences.

C arrays have no built-in length property — a common idiom is sizeof(array) / sizeof(array[0]) to compute the element count from the total byte size. This only works on stack arrays, not pointers. C has no for-each loop for arrays; C++11 added range-based for, but plain C requires an index variable.

Pascal's SetLength is handled automatically by the runtime. In C, dynamic arrays are raw heap memory managed with malloc/free. You must track the count yourself (C does not store it), check for allocation failure, and free the memory when done. Forgetting to free is a memory leak; freeing twice is a crash.

The pointer symbols are inverted between the languages: Pascal's ^TType declares a pointer type; C's int * declares a pointer to int. Pascal's @variable takes the address; C's &variable takes the address. Pascal's pointer^ dereferences (caret after); C's *pointer dereferences (asterisk before).

C pointer arithmetic automatically scales by the element size — pointer++ on an int * advances by sizeof(int) bytes, just like Pascal's Inc(pointer). In C, an array name decays to a pointer to its first element in most contexts, which is why pointer = numbers works without &.

C's if requires parentheses around the condition — if (condition). Pascal uses then instead. C uses braces {} for multi-statement blocks; Pascal uses begin/end. For single statements, both languages allow the body without braces/begin-end, though braces are recommended in C to avoid the dangling-else ambiguity.

C's switch falls through from one case to the next unless you add break. Pascal's case does not fall through — each branch exits automatically. This is one of the most common Pascal-to-C bugs: forgetting break runs the next case body. Multiple values in Pascal (6, 7:) become stacked case 6: case 7: labels in C.

Pascal uses := for assignment and = for equality — they are distinct operators. C uses = for assignment and == for equality. The accidental if (x = 5) in C is a legal expression (assigns 5, tests non-zero) — a notoriously silent bug. GCC's -Wall warns about this; writing if (5 == x) ("Yoda condition") prevents it entirely.

Pascal's for is restricted: it always steps by exactly 1 (or -1 for downto), and the loop variable must be an ordinal type. C's for (init; condition; step) is completely general — the step can be any expression (i += 2, i *= 2), and the condition can test anything. C arrays are 0-indexed, so C for loops conventionally start at 0.

The while loop structure is identical in both languages. Pascal uses begin/end for the body; C uses {}. Pascal's Inc(count) increments by 1; C's count++ (postfix) or ++count (prefix) do the same. C also has the += compound assignment: count += 1.

Pascal's repeat...until loops until the condition is true. C's do...while loops while the condition is true. Both execute the body at least once before checking the condition. To convert: negate the Pascal condition — until number > 5 becomes while (number <= 5).

Pascal distinguishes procedure (no return value) from function (has a return value). C uses only void return type for the equivalent of a procedure — both are just functions syntactically. In C, all functions (including main) must be declared before use, or you must provide a prototype above the call site.

Pascal uses an implicit Result variable (or the function name itself as the target). C uses an explicit return statement. C also has the ternary operator condition ? true_value : false_value — Pascal has no equivalent and requires a full if...then...else. Note: max conflicts with the C standard library macro on some systems — use a different name.

Pascal's var parameter is pass-by-reference — the function receives a reference to the caller's variable. C has no pass-by-reference; you pass a pointer explicitly with &x and dereference with *a inside the function. The effect is the same, but C makes the mechanism explicit at every call site.

Pascal records and C structs are nearly identical in concept: named fields with types, laid out sequentially in memory. The main syntax differences: C omits the record...end wrapper, uses braces, and requires a semicolon after the closing brace. C struct fields cannot hold Pascal's heap-managed String — strings must be char arrays with a fixed maximum length.

In C, struct person requires the struct keyword every time it is used as a type. The typedef struct { ... } name_t; pattern creates an alias so you can write just name_t. Pascal's type TPerson = record always creates a clean alias. Compound initialisers ({0.0, 0.0}) initialise struct fields in declaration order.

Pascal uses pointer^.field to access a field through a pointer. C's arrow operator pointer->field is shorthand for (*pointer).field. The arrow operator was introduced specifically because dereferencing-then-accessing is so common with struct pointers. person->name reads as "the name field of the struct that person points to."

Pascal's New(pointer) allocates exactly enough memory for the pointed-to type. C's malloc(n * sizeof(type)) is more explicit — you specify the byte count. Always check for NULL (allocation failure) before using the returned pointer. Both languages require a matching deallocation: Pascal's Dispose and C's free.

Pascal's nil and C's NULL are both the null pointer constant. NULL is a macro defined in <stddef.h> (and several other headers). In C, dereferencing a null pointer is undefined behaviour — it typically causes a segmentation fault. C11 introduced the more expressive nullptr keyword via <stddef.h>'s nullptr_t; C23 makes nullptr a built-in keyword.

realloc resizes a heap allocation, preserving existing contents — the C equivalent of Pascal's SetLength. Crucially, realloc may return a different pointer if it needs to move the data to find a larger block. Always assign the result to a separate pointer before overwriting the original, so you can free the old block if realloc fails.

Pascal is more strictly typed than C: assigning a double to an integer is a compile error; you must call Round or Trunc explicitly. C silently truncates — int x = 3.7 gives 3 without any error. GCC's -Wconversion flag adds warnings for these implicit conversions, but they remain legal C.

C enums are less type-safe than Pascal's: a C enum value is just an int, and you can assign any integer to an enum variable without a cast. Pascal enum variables can only hold valid enum values, and the compiler enforces this. Conventionally, C enum constants are all-caps (RED) to distinguish them from variables.

Pascal's set of type is a high-level bit-set abstraction with readable operators (in, +, -, *). C has no equivalent — the idiom is manual bitfield manipulation with | (union), & (intersection), and &~ (set difference). The #define flag approach is conventional and efficient, but loses all type safety.

Pascal's subrange types (1..12) are a first-class feature: the type system knows the valid range, and the runtime can verify it. C has no equivalent — you validate constraints manually. assert from <assert.h> is stripped in release builds (-DNDEBUG). Third-party C libraries (like those based on GNU's checked types) can add bounds checking, but it is never automatic.