C.CodeCompared.To/Ada

Ada replaces C's #include plus printf with an explicit with clause that names the exact package providing the functionality. On Compiler Explorer the source file is always named example.adb, so the main procedure must be named Example.

gnatmake is Ada's all-in-one build tool: it figures out which source files a program depends on, compiles only what changed, and links the executable. There is no separate object-file bookkeeping to manage by hand, unlike a typical C Makefile.

Ada has only one comment style, -- to end of line — there is no equivalent of C's /* ... */ block comment. Every line of a long comment needs its own leading --.

Ada identifiers are case-insensitive: Count, count, and COUNT all refer to the same declaration, and declaring two of them in the same scope is a compile error. C is case-sensitive, so Count and count are unrelated variables — a common source of confusion when porting code between the two languages.

Ada has a real Boolean type built in, so there is no need for C's 0/1 convention or the <stdbool.h> header. Declarations live between is and begin, and every variable can carry an inline initializer with :=.

C freely converts between numeric types wherever it needs to, sometimes losing precision or wrapping without warning. Ada requires an explicit conversion, such as Float(Whole) or Character'Val(65), at every point where the type actually changes — the compiler will not silently insert one.

Ada provides Natural (values ≥ 0) and Positive (values ≥ 1) as predefined subtypes, giving a built-in replacement for C's convention of using unsigned int to mean "non-negative." Underscores may separate digit groups in numeric literals for readability, just like C's 1000000 written as 1_000_000 in Ada.

A C cast such as (int)pi truncates toward zero. Converting a floating-point value to Integer in Ada instead rounds to the nearest integer — Integer(3.9) yields 4, not 3. Reaching for a familiar C-style cast and expecting truncation is a common mistake.

A C string is a char array terminated by a '\0' byte, and its length must be discovered with strlen. An Ada String is a fixed-length array of Character with no terminator — the length is a fixed part of the type itself and is available instantly as the 'Length attribute.

Growing a C string means manually tracking a buffer size, calling realloc, and remembering to free it. Ada's Unbounded_String from Ada.Strings.Unbounded resizes itself automatically as text is appended, with no manual allocation, reallocation, or freeing required.

C string concatenation goes through strcat, which writes past the end of the destination buffer with no bounds check if the buffer is too small — a classic source of buffer overflows. Ada uses the & operator, and an Unbounded_String grows to fit the result automatically with no manual buffer sizing at all.

C substrings require manual pointer arithmetic (word + 1) plus remembering to add a null terminator by hand. Ada slices an array directly with a range, Word(2 .. 4), and the result is itself a proper bounded String with no separate terminator step.

Indexing a C array out of bounds is undefined behavior: the compiler is free to do anything, and in practice the program often reads or writes memory that does not belong to the array. Ada checks every array index at runtime by default and raises Constraint_Error the instant a bound is violated, turning a silent memory bug into an immediate, catchable exception.

Because Ada raises a real exception for an out-of-range index, the program can catch it with an ordinary exception when Constraint_Error handler and recover gracefully. C provides no equivalent detection mechanism at all — the invalid access simply happens.

Signed integer overflow in C is undefined behavior — the standard places no requirement on what happens, and optimizing compilers sometimes exploit that to remove overflow checks the programmer wrote. Ada raises Constraint_Error the moment an arithmetic result exceeds the range of its type, so overflow is always detected rather than silently wrapping or invoking undefined behavior.

In C, enforcing that a value stays within a range means writing and remembering a manual check at every assignment site. Ada's subtype bakes the constraint into the type itself: Grade_Type can never legally hold a value outside 0 .. 100, and the compiler and runtime enforce it everywhere the type is used, not just where the programmer remembered to check.

Ada spells the "else if" chain as a single keyword, elsif, and closes the whole construct with end if;. There are no curly braces anywhere in Ada — indentation is purely a style convention, not a syntactic requirement, and the explicit end if is what actually delimits the block.

Ada's case has no fallthrough and therefore needs no break — each when arm ends automatically. It also requires every possible value to be covered, either explicitly or with when others, so the compiler rejects a case that accidentally misses a value; C's switch allows silent fallthrough and does not require a default case.

C's && and || always short-circuit. Ada instead has two separate forms: bare and/or always evaluate both sides, while and then/or else short-circuit like C's operators. Reaching for bare and where a guard condition must run first, such as an index check before an array access, is a common mistake for a C programmer new to Ada.

Ada's for Index in Low .. High loop has no separate initializer, condition, or increment clause to get wrong — the loop variable is declared implicitly, is read-only inside the loop, and stops existing once the loop ends. Ada array and range conventions commonly start at 1 rather than C's near-universal 0-based indexing, so a direct 0 .. 4 translation of a C loop is often not idiomatic Ada.

The range in for Index in reverse 1 .. 5 loop is still written low to high; the reverse keyword alone drives iteration backwards. Writing 5 .. 1 directly, mirroring a C-style descending loop bound, produces an empty range instead of an error.

Ada has no ++ or += operators — an increment is always written out fully as Count := Count + 1. The loop body is delimited by loop ... end loop; rather than curly braces.

Ada has no dedicated do...while form. The idiom is a bare loop ... exit when Condition; end loop;, and because exit when may appear anywhere in the body — not only at the end — the same construct also covers loops that need to check their exit condition in the middle.

The 'Range attribute yields an array's own declared bounds, so a loop written as for Index in Numbers'Range loop automatically covers every element no matter how the array's bounds are defined — there is no risk of a C-style off-by-one error from a hardcoded < 5 condition.

Ada makes the C distinction between "returns a value" and "returns nothing" explicit at the language level: a procedure never returns a value, matching C's void functions, while a function (below) always must. Parameters default to in mode, meaning read-only, unlike C where every non-pointer parameter is silently copied and freely mutable inside the function body.

An Ada function declares its return type with return Integer in the signature and must return a value on every path — the compiler rejects a function with a path that falls off the end without a return statement, unlike C where a missing return is merely undefined behavior if the value is used.

C has only one parameter-passing mode, so mutating a caller's variable requires manually passing a pointer and dereferencing it with * at every use. Ada's in out mode lets a parameter be both read and written using ordinary variable syntax, with no pointers or address-of operators anywhere at the call site.

Ada's out mode documents, and in many compilation modes enforces, that a parameter is write-only: the subprogram must not depend on the caller's initial value. A C pointer parameter used the same way carries no such guarantee — nothing in the language stops the function from reading the pointee before writing it.

Ada's record plays the same structural role as C's struct, including the same dot-notation field access. Named aggregates, (X => 0, Y => 0), initialize every field in one expression — C's equivalent, {0, 0}, relies on positional order and gives no field-name safety net.

Nested records work exactly like nested structs, with the same chained dot access, Box.Top_Left.X. The named aggregate form makes the nesting explicit at the initializer, unlike C's positional {{0, 0}, 10, 20}, which relies entirely on remembering field declaration order.

Both languages pass structs and records to subprograms by value by default, copying the whole aggregate. Ada makes that copy read-only unless the parameter mode is explicitly in out, whereas a C function can freely mutate its local copy of a struct parameter — the caller's original is unaffected either way, but only Ada enforces the read-only intent at compile time.

C's malloc/free pair requires the programmer to track every allocation and release it exactly once — forgetting leaks memory, and freeing twice or using the pointer afterward corrupts the heap. Ada's access types allocate with new, and there is no direct equivalent of free in ordinary use; the language leaves deallocation to a storage pool rather than an explicit call the programmer must remember.

C's unary * dereferences a pointer on both the reading and writing side of an assignment. Ada spells the same operation .all, which reads more like ordinary field access: Pointer.all gets or sets the integer the access value designates.

Both languages have a null pointer value, spelled NULL in C and null in Ada. The behavior on dereference differs sharply though: dereferencing a null pointer in C is undefined behavior, typically a segmentation fault with no recovery, while dereferencing a null access value in Ada raises Constraint_Error, which the program can catch and handle.

C requires the arrow operator, pointer->name, to access a field through a pointer, distinct from the dot used on the struct value directly. Ada automatically dereferences an access value for record field access, so Pointer.Name is shorthand for Pointer.all.Name — there is no separate arrow syntax to remember.

A C header declares an interface that is textually pasted into every including file by the preprocessor, protected from double inclusion only by manual #ifndef guards. Ada's package spec (.ads) plays the same role natively, without a preprocessor or include guards, and the compiler itself enforces that the body (.adb) actually matches the spec it implements.

C's #include is a textual, preprocessor-level operation with no understanding of the language underneath it. Ada's with clause is a real compiler-level dependency declaration on an already-compiled package — there is no preprocessor step, and referencing a package that does not exist is a compile error rather than a header search failure.

A C #define constant is untyped text substitution performed before compilation even starts, so the compiler cannot type-check its uses. Ada's constant is a genuinely typed, compiler-checked declaration — Max_Size is an Integer and using it where an Integer is not expected is a compile error, not a silent substitution.

A C function-like macro is textual substitution and can evaluate its argument multiple times, producing surprising bugs when the argument has side effects, such as n++. Ada has no macro system at all — an ordinary function evaluates each argument exactly once, the same as any normal subprogram call.

C has no built-in exception mechanism — errors are communicated through a return code, a global like errno, or an out-parameter, and it is entirely up to the caller to remember to check it. Ada raises Constraint_Error automatically for division by zero, and the exception propagates on its own until something catches it — there is no way to silently ignore it the way a C caller can skip an error-code check.

Every begin...end block in Ada can end with an exception section listing one or more when handlers, playing the role of C++'s try/catch — a facility plain C simply does not have. Multiple when clauses match specific exceptions, and when others is the catch-all.

Declaring a custom exception in Ada is a single line, Invalid_Age : exception;, and raise Invalid_Age with "message" attaches a description without building a whole error-info struct by hand. Reading the message back requires Ada.Exceptions.Exception_Message, so a fully worked example needs that package as well.

C lets any function whose signature matches be assigned to a function-pointer variable with no explicit marker. Ada requires a named access-to-subprogram type, such as Binary_Operation, and the target subprogram must be marked explicitly with the 'Access attribute — the language will not let a subprogram's address be taken silently.

Ada restricts which subprograms may have 'Access taken for a general access-to-subprogram type, primarily to prevent a dangling reference to a nested subprogram whose enclosing frame has already returned. Ordinary C function pointers carry no such restriction — pointing at a function is always allowed, though pointing at a stack-allocated nested function via GCC's non-standard extension carries the same lifetime danger without the compiler stopping it.

Ada uses := for assignment and plain = for comparison, so there is no single character that means two different things depending on context — the classic C bug of writing if (count = 5) when == was intended cannot happen, because = alone is never a valid assignment.

Writing bare and instead of and then is the single most common Ada gotcha for a C programmer: and always evaluates both operands, so a guard condition meant to prevent a division by zero would not actually prevent it. Only and then/or else short-circuit the way C's &&/|| always do.

Ada spells "not equal" as /=, borrowed from mathematical notation, rather than C's !=. There is also no ! operator for logical negation at all — Ada uses the keyword not instead.

C array indices are always 0-based — the language gives no choice. Ada array bounds are chosen explicitly by the programmer in the type or object declaration, and existing Ada code very commonly starts at 1, so porting a C loop or index expression verbatim, without adjusting for the different base, is a frequent source of off-by-one bugs when moving between the two languages.

C silently mixes int and double in an expression, applying its own conversion rules that can produce a surprising result, such as integer division happening before the conversion to double. Ada refuses to mix Integer and Float in an expression at all; both operands must be the same type, so the programmer must write the conversion explicitly and therefore see exactly where it happens.

Closing an Ada procedure, function, package, or record with end Name; — repeating the identifier being closed — is optional but strongly conventional, and if written, the compiler checks that the name actually matches. C's closing } carries no name at all, so a misplaced or mismatched brace is caught only indirectly, often far from the real location of the mistake.