C.CodeCompared.To/Ada

Put_Line lives in Ada.Text_IO; the use clause makes it callable without the full Ada.Text_IO.Put_Line prefix.

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.

Every line of a long comment needs its own leading --.

Declaring two spellings of the same name in one scope is therefore a compile error in Ada. C is case-sensitive, so Count and count are unrelated variables — a common source of confusion when porting code between the two languages.

There is no need for C's 0/1 convention or the <stdbool.h> header, and every variable can carry an inline initializer with :=.

The conversions here are Float(Whole) and Character'Val(65) — the compiler will never silently insert one.

Underscores may separate digit groups in numeric literals for readability — C's 1000000 is written 1_000_000 in Ada. (C itself only gained digit separators, spelled with ', in C23.)

Integer(3.9) yields 4, not 3 — reaching for a familiar C-style cast and expecting truncation is a common mistake. When truncation is genuinely wanted, use Integer(Float'Truncation(Pi)).

A C string is a char array terminated by a '\0' byte, and its length must be discovered with strlen; Ada's length is available instantly as the 'Length attribute.

Growing a C string means manually tracking a buffer size, calling realloc, and remembering to free it; Unbounded_String needs no manual allocation, reallocation, or freeing at all.

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. With &, 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; the Ada slice has no separate terminator step.

In C 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 raises Constraint_Error the instant a bound is violated, turning a silent memory bug into an immediate, catchable exception.

C provides no equivalent detection mechanism at all — the invalid access simply happens.

The C standard places no requirement on what happens after signed overflow, and optimizing compilers sometimes exploit that to remove overflow checks the programmer wrote. In Ada, 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. 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.

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.

The compiler rejects a case that accidentally misses a value; C's switch allows silent fallthrough and does not require a default case. Note the alternatives syntax: 12 | 1 | 2 lists values, 3 .. 5 covers a range.

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 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.

Writing 5 .. 1 directly, mirroring a C-style descending loop bound, produces an empty range (a loop that never runs) rather than an error.

The loop body is delimited by loop ... end loop; rather than curly braces.

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.

There is no risk of a C-style off-by-one error from a hardcoded < 5 condition — change the array's bounds and the loop follows along.

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.

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.

The call site uses ordinary variable syntax — Swap(X, Y), with no & address-of operators — and the body needs no * dereferences. C has only the one parameter-passing mode, so the pointer machinery appears at every use.

The mode both documents the intent and, in many compilation modes, enforces it. 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.

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.

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.

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.

The malloc/free pair requires the programmer to release every allocation exactly once — forgetting leaks memory, and freeing twice or using the pointer afterward corrupts the heap. Ada is not garbage-collected: by default an allocation simply lives until the program ends (or until its access type's storage pool is reclaimed), and explicit freeing requires instantiating Ada.Unchecked_Deallocation — the "unchecked" in the name makes every deliberate free-equivalent loudly visible in the source.

It reads more like ordinary field access: Pointer.all gets or sets the integer the access value designates, on both the reading and writing side of an assignment.

Dereferencing a null pointer in C is undefined behavior, typically a segmentation fault with no recovery. Dereferencing a null access value in Ada raises Constraint_Error, which the program can catch and handle.

C requires the arrow, pointer->name, to access a field through a pointer — a separate syntax from the dot used on the struct value directly. In Ada there is only the dot.

A C header is textually pasted into every including file by the preprocessor, protected from double inclusion only by manual #ifndef guards. Ada needs no preprocessor or include guards, and the compiler itself enforces that the body actually matches the spec it implements.

There is no preprocessor step at all, and referencing a package that does not exist is an ordinary compile error rather than a header search failure.

Because the preprocessor substitutes text before compilation even starts, the C compiler cannot type-check a macro's uses. Max_Size is an Integer, and using it where an Integer is not expected is a compile error, not a silent substitution.

A C macro is textual substitution and can evaluate its argument multiple times, producing surprising bugs when the argument has side effects, such as n++. An Ada function evaluates each argument exactly once, the same as any normal subprogram call.

Ada raises Constraint_Error automatically for division by zero, and the exception propagates on its own until something catches it — it cannot be silently overlooked the way a C caller can skip an error-code check.

Multiple when clauses match specific exceptions, and when others is the catch-all.

The handler names the exception occurrence (when Error : Invalid_Age) so the message can be read back with Ada.Exceptions.Exception_Message, which is why the with Ada.Exceptions; clause appears at the top.

C lets any function whose signature matches be assigned to a function-pointer variable with no explicit marker; Ada will not let a subprogram's address be taken silently.

The restriction exists primarily to prevent a dangling reference to a nested subprogram whose enclosing frame has already returned. Ordinary C function pointers carry no such rule — 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.

No single character means two different things depending on context, so the classic C bug of writing if (count = 5) when == was intended cannot happen — = alone is never a valid assignment.

A guard condition written with bare and, 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.

There is no ! operator for logical negation at all — Ada uses the keyword not instead.

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, applying its own conversion rules that can produce a surprising result — here, integer division happens before the conversion to double, so C prints 2.0. In Ada the programmer writes the conversion explicitly and therefore sees exactly where it happens.

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.