C.CodeCompared.To/D

D uses import modules instead of #include headers — the compiler resolves symbols from compiled .di interface files, eliminating the need for header guards. writeln appends a newline automatically. The main function returns void by default and implicitly exits with code 0.

D allows selective imports (import module : name) that bring only the named symbols into scope. This is idiomatic D style — it documents intent and prevents namespace pollution without requiring name prefixes. Wildcard import std.stdio; also works when you want everything.

D ships with three compilers: DMD (reference, fastest compile times), LDC (LLVM-based, best runtime performance), and GDC (GCC backend). The -unittest flag compiles and runs all unittest blocks before main. The -release flag disables contracts and asserts for production builds.

D's writefln uses the same %d/%s/%f format verbs as C's printf, so the transition is friction-free. The std.format module also provides a Python-style format("%s is %d", name, age) function that returns a string.

D's int is always 32-bit, long always 64-bit, byte always 8-bit signed, ubyte always 8-bit unsigned — no platform variation. C's long is 32-bit on Windows 64-bit and 64-bit on Linux 64-bit, which is why stdint.h exists. D eliminates this portability hazard at the type level.

auto in D is true type inference — the compiler deduces the exact type from the initializer. Unlike C++'s auto, D's auto is available for any variable including loop variables. The inferred type is fixed at compile time; auto is not a dynamic type.

D distinguishes const (a read-only view — the underlying data may still change via another reference) from immutable (transitive deep immutability — the data cannot be changed by anyone). D strings are immutable(char)[], which is why they can be safely shared across threads without locks.

alias in D replaces C's typedef and is more powerful: it can alias templates, function types, and even template parameters. Unlike typedef, alias creates a true transparent alias — the aliased type and the original are identical in the type system, not just compatible.

Every D type exposes compile-time properties via dot syntax: .sizeof, .min, .max, .init (the zero-value), .stringof (the type name as a string). typeof(expr) produces the type of an expression at compile time, analogous to C++ decltype.

D static arrays put the size before the name (int[5] rather than int arr[5]), making the type read left-to-right: "array of 5 ints." The .length property replaces the sizeof/sizeof division. Static arrays in D are value types — assigning one copies all elements.

D dynamic arrays (int[]) are GC-managed — no malloc/free needed. The ~= operator appends a single element or another array. Internally a dynamic array is a fat pointer: a length and a pointer to GC-managed memory. Passing one to a function passes both the length and pointer by value.

D's a[i..j] slice syntax creates a view into the original array — it shares memory, so modifications to the slice affect the original. The special $ symbol means "the length of the array being sliced." Slices are the primary reason D rarely needs pointer arithmetic.

The ~ operator concatenates arrays or appends an element, returning a new array. .dup makes a mutable copy of an array (or string). .idup makes an immutable copy. Since slices share memory, .dup is needed when you want an independent copy to modify.

D's foreach (index, element; collection) form provides both index and value without manual bookkeeping. The variable before the semicolon is the index; the one after is the element. Both variables are typed by inference. Omitting the index (foreach (color; colors)) iterates values only.

D's string type is immutable(char)[] — a slice of immutable UTF-8 bytes. There is no null terminator; .length is always accurate. Indexing gives a char (a UTF-8 byte). To iterate over Unicode code points, use foreach (dchar c; str) or import std.utf : byDchar.

String concatenation with ~ returns a new string without mutating either operand. The std.string module provides toUpper, toLower, strip, split, indexOf, and dozens of other operations. All string operations work on string, char[], and wstring uniformly.

std.conv.to is a single generic function that converts between any compatible types: strings to numbers, numbers to strings, enums to strings, and more. It throws ConvException on failure rather than silently returning 0 like atoi. The exclamation mark (to!int) is D's template instantiation syntax.

std.format.format is the string-building equivalent of snprintf — it returns a string rather than writing to a buffer, so there is no size limit and no buffer overflow risk. For simple cases, ~ concatenation with to!string conversions also works.

D's 0..5 is a built-in integer range literal; foreach (i; 0..5) iterates 0, 1, 2, 3, 4 without creating a range object. foreach_reverse iterates from high to low. For non-integer ranges, std.range.iota(start, stop, step) provides strided ranges.

D's switch requires an explicit break or goto case in every case — accidental fallthrough is a compile error, eliminating a classic C bug. Multiple values can be listed as case 3, 4: instead of stacking empty cases. The goto case statement falls through to the next case when you genuinely want that behavior.

D supports labeled break and continue statements — the label is placed before the loop, and break label exits that specific loop. This replaces C's common pattern of using a flag variable or goto to escape nested loops. continue outer similarly skips to the next iteration of the outer loop.

static if is a compile-time conditional that operates on real D expressions, not preprocessor text. The condition must be evaluable at compile time, and only the selected branch is compiled. Unlike #if, static if can appear inside functions, structs, and templates, and can inspect type properties and template parameters.

D supports default parameter values directly in the function signature — no duplicate function needed. Default values must be compile-time constants or expressions. Parameters with defaults must come after parameters without defaults. Callers can still pass arguments positionally.

D supports full function overloading — multiple functions with the same name, differentiated by parameter types. The compiler selects the best match at the call site. Overloading works across modules and interacts correctly with templates and UFCS, so 42.display() also resolves to the int overload.

Universal Function Call Syntax (UFCS) means any free function f(x, args) can be called as x.f(args). This enables method chaining on any type without modifying it — the foundation of D's range pipeline style (data.filter!(...).map!(...).sum()). There is no performance difference; the compiler transforms one form to the other.

D supports fully portable nested functions — functions defined inside other functions, invisible outside their enclosing scope. Nested functions can access and modify variables from the enclosing function (they are closures when the enclosing variables need to outlive the call). This is a core language feature, not a compiler extension.

D function attributes are verified by the compiler, not just hints: pure means no global state access (the compiler enforces this); @safe means no pointer casts, no undefined behavior; nothrow means no exceptions; @nogc means no GC allocations. These attributes compose — a @safe pure nothrow function is maximally constrained and highly optimizable.

D structs are value types (like C structs) but can have methods, constructors, and operator overloads. The const method qualifier means the method does not modify the struct — the compiler enforces this. Structs are stack-allocated by default; use new to heap-allocate a pointer to one.

D structs use this(params) as the constructor syntax. The inline contract in (condition, "message") on the constructor is checked at runtime in debug builds and skipped in release builds (-release). Unlike C, the constructor is called with the struct name as a function: Rectangle(5, 3).

D uses template operator methods: opBinary(string op : "+") overloads +, opEquals overloads ==, opCmp overloads ordering comparisons, opIndex overloads [], opCall overloads (). The toString method is called automatically by writeln and string conversion — no separate format machinery needed.

The @property attribute makes a method callable without parentheses — temp.celsius calls the getter, temp.celsius = 100 calls the setter. This lets you start with a public field and later replace it with a computed property without changing any calling code, the same pattern as Ruby's attr_accessor → custom getter/setter refactor.

D classes are reference types — new Person(...) allocates on the GC heap and returns a reference. Passing a class variable copies the reference, not the object (unlike a struct, which copies the value). The GC collects unreachable objects automatically. For value-type semantics, use a struct.

D supports single inheritance with the class Child : Parent syntax. The override keyword is required when overriding a virtual method — forgetting it (or misspelling the method name) is a compile error, preventing a common C++ bug. abstract marks a method with no body that subclasses must implement.

D interfaces are pure abstract types — all methods must be overridden, and an interface cannot have member fields or method bodies. A class can implement multiple interfaces. Interface references provide dynamic dispatch without knowing the concrete type at compile time.

final can be applied to individual methods (preventing override in subclasses) or to an entire class (preventing any subclassing). A final method is also a performance hint — the compiler can devirtualize the call and inline it. final class is equivalent to Java's final class or Rust's sealed pattern.

D function templates use T as the type parameter in a second pair of parentheses before the argument list: func(T)(T arg). The compiler infers T from the argument types — explicit instantiation (max!int(3, 7)) is rarely needed. Unlike C macros, templates are type-safe, evaluated in the function's own scope, and show meaningful error messages.

Template constraints (if (condition) after the parameter list) restrict which types a template accepts. The constraint must be evaluable at compile time — typically using traits from std.traits: isNumeric, isIntegral, isFloatingPoint, isSomeString, isArray, etc. A failed constraint produces a readable "template is not callable" error.

CTFE (Compile-Time Function Execution) means that ordinary D functions can run at compile time when used in a compile-time context — no special keyword needed. Using enum as a variable declaration forces the value to be computed at compile time. The same function works at both runtime and compile time, unlike C where compile-time constants require separate metaprogramming machinery.

D's mixin(string) injects D source code into the surrounding scope at compile time — a hygienic alternative to C macros. The string is produced by an ordinary function or CTFE expression, so it has full access to the type system. Unlike preprocessor text substitution, a mixin is parsed and type-checked after injection.

D's garbage collector makes memory management automatic for typical code — new allocates on the GC heap and the runtime collects unreachable objects. You can still use manual allocation via core.stdc.stdlib.malloc/free or std.experimental.allocator for performance-critical sections.

scope(exit) registers a cleanup action that runs when the current scope exits — whether by normal return, exception, or any other path. This eliminates the need to duplicate cleanup code across every return path, and is the D equivalent of RAII destructors or Go's defer. scope(success) runs only on normal exit; scope(failure) only on exception.

scope(success) runs only when the scope exits normally (no exception); scope(failure) runs only when an exception propagates out. Together they model a transaction pattern: prepare in the body, commit in scope(success), rollback in scope(failure) — without wrapping everything in a try/catch.

D provides direct access to C's malloc/free via core.stdc.stdlib for performance-critical sections that must avoid GC pressure. The cast(int*) is required because D's malloc returns void*, the same as C. The @nogc function attribute prevents accidental GC allocation in code that must remain GC-free.

D's std.algorithm functions accept any range (arrays, lazy ranges, custom types) and return lazy ranges themselves. The ! is the template instantiation operator — filter!(x => x % 2 == 0) specializes filter with the lambda predicate at compile time. Calling .array() at the end forces evaluation and collects results into a heap array.

std.algorithm.reduce is a left fold with an initial seed or two-argument accumulator. Common reductions have named shortcuts: .sum(), .minElement(), .maxElement(). The reduce!((a, b) => ...) form accepts any binary function as a template argument, evaluated at compile time for zero overhead.

std.algorithm.sort sorts in place and uses an introsort hybrid (unstable). The template predicate sort!((a, b) => a > b) inverts ordering without a separate comparator function. find returns the remaining range starting at the match — a D idiom that avoids returning an index that would need bounds checking.

std.range.iota(start, stop, step) generates integers lazily — it computes each value on demand and never allocates a backing array. Chaining .map and .sum on a lazy range means the entire pipeline runs in a single pass with no temporary storage, equivalent to the C loop.

D exceptions use try/catch/finally, identical to Java and C#. Exception represents recoverable errors; Error (a separate hierarchy) represents unrecoverable failures like assertion errors and out-of-memory. Catching Exception does not catch Error, which propagates until the program terminates.

Custom exceptions inherit from Exception (or another exception class). The super(msg) call passes the message to the base class constructor. Catch blocks are checked top-to-bottom — put more specific types before more general ones. The Throwable root class covers both Exception and Error.

std.exception.enforce(condition, message) throws an Exception if the condition is false — it is the "throw on false" counterpart to assert. Unlike assert, enforce is never disabled by -release and is appropriate for runtime input validation. Use assert for invariants you control; use enforce for external conditions you cannot guarantee.

nothrow is a compiler-verified guarantee that a function does not propagate exceptions. Code inside a nothrow function cannot call throwing functions (unless wrapped in a try block). This enables the compiler to skip exception-handling overhead in call sites and is required when interfacing with C code via extern(C).

D's in contract (in (condition, "message")) is a precondition checked at the start of every function call in debug mode and disabled in release mode (-release). It documents the function's expectations as executable specification. The older multi-statement form uses in { assert(condition); } before do { ... }.

The out (result; condition) contract binds the return value to result and checks the condition after the function returns. This is the standard design-by-contract postcondition. in and out contracts are inherited by overriding methods: an override can only weaken preconditions and strengthen postconditions.

unittest blocks are compiled only when -unittest is passed to the compiler. They run automatically before main — no test runner framework needed. Each module can have multiple unittest blocks anywhere in the file, typically adjacent to the function being tested. A failing assertion prints the file and line number.

An invariant block in a struct or class is checked automatically before and after every public method call in debug mode. This guarantees that the object is always in a consistent state — you cannot accidentally leave it in an invalid state after a method call. Like contracts, invariants are disabled by -release.

extern(C) declares a function with C linkage and ABI — the D compiler will call it with the C calling convention rather than the D convention. The C standard library is linked by default, so any libc function can be declared and called this way. The core.stdc.* modules pre-declare the most common C stdlib headers.

The core.stdc.* modules are D's pre-built bindings to C's standard library: core.stdc.stdio, core.stdc.stdlib, core.stdc.string, core.stdc.math, etc. These are preferable to hand-writing extern(C) declarations. The fromStringz function converts a null-terminated char* to a D string.

extern(C) struct makes a D struct use the C ABI field layout — this is required when passing structs to or from C code via pointers. Without extern(C), the D compiler may reorder or pad fields differently. An extern(C) function can be exported as a symbol callable directly from C code compiled separately.