C.CodeCompared.To/Go

Go automatically wraps snippets in package main and func main(). The fmt import is added automatically by this runner.

Go has a single toolchain with no Makefile required. go run compiles and executes in one step. go build produces a statically linked binary with no runtime dependencies.

Go imports package paths, not header files. There are no header/source splits. Unused imports are a compile error, preventing the header-bloat that C codebases accumulate over time.

The := operator declares and initializes in one step with type inferred from the right side. Explicit typed form: var count int = 0. All Go variables are zero-initialized by default — no garbage values.

Go's integer types are explicit and portable — int8, int16, int32, int64 and unsigned variants. No stdint.h required. Plain int is 64-bit on 64-bit platforms.

Go has a native bool type. Unlike C, integers are never implicitly treated as booleans — if 1 is a compile error. This eliminates an entire class of C bugs.

iota is Go's enumeration mechanism — it auto-increments within a const block, replacing C's enum. Go constants can be untyped and arbitrarily precise, avoiding the overflow surprises of C's #define.

Go requires explicit type conversions between numeric types. There are no implicit promotions, eliminating the silent truncation and precision-loss bugs that C's arithmetic rules are infamous for.

Go strings are immutable byte sequences with a stored length — len() is O(1). They are not null-terminated and can contain any bytes including null. No buffer overflows from missing null terminators.

Go strings concatenate with +. For building strings in a loop, strings.Builder is the efficient equivalent of a C character buffer. No manual buffer sizing or overflow risk.

fmt.Sprintf returns a string — no pre-allocated buffer needed, no size limit. The format verbs are similar to printf but %v prints any type automatically.

Go source and strings are UTF-8 by definition. A rune is a Unicode code point (alias for int32). Iterating with range over a string yields runes, not bytes.

Go arrays are values — assigning an array copies it entirely. The size is part of the type: [5]int and [10]int are incompatible types. Arrays are rarely used directly; slices are preferred.

A slice is a reference to a backing array with length and capacity metadata. append grows it automatically — no manual realloc. This is the Go equivalent of a C dynamic array, without the memory management burden.

Go's built-in map is a hash table with O(1) average operations — no external library. Accessing a missing key returns the zero value; use value, ok := m[key] to distinguish "missing" from "zero".

Go performs runtime bounds checking on every slice/array access. Out-of-bounds access panics with a clear error instead of silently corrupting memory. This eliminates a major category of C security vulnerabilities.

Go's garbage collector eliminates use-after-free, double-free, and memory leak bugs. The GC runs concurrently, typically adding sub-millisecond pauses. For most applications the throughput cost is negligible.

new(T) is analogous to malloc(sizeof(T)) but returns a typed pointer and zero-initializes. make is only for slices, maps, and channels. Both are freed automatically by the GC.

Go's compiler performs escape analysis — variables that outlive their function are automatically heap-allocated. Returning a pointer to a local variable is safe in Go; the compiler moves it to the heap. In C, that is undefined behavior.

Go pointer syntax is identical to C: & takes an address, * dereferences. What Go lacks is pointer arithmetic — you cannot do ptr++ or ptr + 2. This eliminates buffer overflows from manual pointer walking.

Go deliberately omits pointer arithmetic. Array traversal is done with range or index expressions. The unsafe package provides pointer arithmetic for systems programming, but it bypasses all safety guarantees.

Go's nil is the zero value for pointers, interfaces, slices, maps, channels, and functions. Dereferencing a nil pointer panics with a clear message instead of undefined behavior.

Go has only one loop keyword: for. It covers C's for, while, and infinite loops. No parentheses around the condition, but braces are required.

A for with only a condition is Go's while. An infinite loop is for { ... } — equivalent to C's while(1) { ... }.

range yields (index, value) pairs for slices, (key, value) for maps, and (index, rune) for strings. Use _ to discard either: for _, value := range scores.

Go's switch does not fall through by default — no break needed. Use fallthrough explicitly when you want C's behavior. Cases can match multiple values: case 1, 2, 3:.

Go functions can return multiple values cleanly — no output pointer parameters needed. The idiomatic pattern for errors: value, err := someFunc().

Go variadic functions receive a typed slice, not a raw va_list. This is type-safe and bounds-checked. Spread a slice into variadic args with sum(numbers...).

Go functions are first-class values. Anonymous functions (closures) can capture variables from the enclosing scope — unlike C function pointers, which cannot close over local variables without a separate context struct.

defer schedules a function call to run when the enclosing function exits — whether normally or via panic. It replaces the C pattern of duplicating cleanup code at every return and the goto cleanup idiom.

Go structs are similar to C structs — no classes, no inheritance. Exported fields start with a capital letter (visible outside the package); unexported fields start lowercase.

Go methods attach functions to types via a receiver. Value receivers (point Point) get a copy; pointer receivers (point *Point) modify the original. This is identical in spirit to C's "pass struct pointer as first arg" convention, formalized in the language.

Go embedding promotes the fields and methods of the embedded type to the outer struct. This is Go's primary composition mechanism — not inheritance. There is no polymorphism implied.

Go interfaces are satisfied implicitly — if a type has the required methods, it satisfies the interface with no declaration needed. This is structural typing, eliminating the manual vtable wiring that C requires for polymorphism.

any (alias for interface{}) accepts any value. Unlike C's void*, it carries runtime type information — use a type switch or type assertion to extract the concrete value safely.

Go returns errors as values — result, err := fn() followed by if err != nil. This is explicit and impossible to accidentally ignore, unlike C's global errno which is often overlooked.

fmt.Errorf("...: %w", err) wraps an error with context. errors.Is unwraps chains to find a target error. This gives structured error propagation that C's errno-based system entirely lacks.

panic is Go's equivalent of abort — for truly unrecoverable situations. recover inside a defer can catch a panic and convert it to an error. This is rare in Go; most error handling uses return values.

Goroutines are multiplexed on OS threads by the Go runtime — starting one costs ~2KB of stack vs ~8MB for a typical POSIX thread. A program can run millions of goroutines. The go keyword launches one with no thread-creation overhead.

Channels are typed communication pipes between goroutines. Go's motto: "Don't communicate by sharing memory; share memory by communicating." Channels replace the mutex + shared state pattern that dominates C concurrent code.

Go packages are directory-based units of encapsulation. Capital-letter names are exported (public); lowercase is unexported (private). This replaces C's convention of static for file-local visibility.

Go modules (go.mod) are the standard dependency system — no Makefile or CMake required. Dependencies are versioned, checksummed, and cached. Reproducible builds work out of the box.

Every Go variable is initialized to its zero value — no garbage. Integers are 0, strings are "", booleans are false, pointers are nil. This eliminates an entire class of C bugs from reading uninitialized memory.

Go structs are value types — assignment copies the entire struct. C programmers expect this, but Go newcomers from OOP languages often don't. Pass a pointer *Point to avoid copying or to allow mutation.

The Go GC is a tradeoff: you give up deterministic memory control but gain freedom from use-after-free and leaks. For most applications this is excellent. For hard real-time requirements, C or Rust remains the better choice.

Go has no header files. The compiler reads all .go files in a package together — function order is irrelevant, no forward declarations needed. This eliminates the class of C bugs where declaration and definition disagree.