C examples

Print a greeting using printf.

printf can be called multiple times.

Hard-coded greeting message.

printf with a format specifier.

Floats use %f.

Use %c for a single char.

Combine formats in one call.

\t for tab, \n for newline.

main returns an integer (0 = success).

A valid C program need not print anything.

Smallest valid C program.

printf is in <stdio.h>.

Multiple statements.

Output stays on same line.

Compute and print in one call.

Escape double quotes with backslash.

Use \\ to print a literal backslash.

Embed multiple \n in one string.

Long string in a single call.

puts adds a newline automatically.

Every statement ends with `;`.

{} groups statements.

Type, name, parameters.

stdio.h gives us printf.

// is ignored by the compiler.

/* … */ for blocks.

C does not care about indentation.

Two statements separated by semicolons.

Variable names are case-sensitive.

Non-zero return signals an error.

%d prints an integer.

%f prints a float; .2 limits precision.

%s prints a string literal.

%5d right-pads to 5 chars.

scanf reads from stdin.

Read two values.

%c reads one character.

Char-level I/O.

puts auto-newlines, printf does not.

\t for tab, \n for newline.

// is ignored to end of line.

/* ... */ spans many lines.

Disable a line of code.

Comment after a statement.

Common author note.

Short header at top of file.

Comment a region.

Mark known issues.

Document a helper function.

Often appears at file top.

int holds whole numbers.

float for decimals.

double has more precision.

char holds one character.

Strings are char arrays.

Comma-separate same-type vars.

A variable can be reassigned.

const cannot be reassigned.

Names must start with letter or _.

Add and print.

Typical 32-bit int.

Smaller / larger int variants.

Only non-negative values.

Different precision.

char is a 1-byte integer.

Bytes per type.

Modern C99 booleans.

Same memory, different range.

64-bit integer.

Auto-promotes int to double.

Promotes automatically.

(double) before the value.

Truncates the decimal part.

Get ASCII code.

Cast back to character.

Big int → small short.

Demonstrate loss.

int + float = float.

5/2 == 2 unless cast.

Cast generic void pointer.

Compile-time constant.

Constants with decimals.

Read-only string.

Preprocessor constant.

Macros can be expressions.

enum gives auto-numbered constants.

Cannot reassign the pointer itself.

Cannot modify what it points at.

Stack several macros.

Use const for loop bounds.

+ - * / and %.

+=, -=, *=, /=.

++ and --.

< > == != <= >=.

&& || !

Bit-by-bit AND.

Bit-by-bit OR.

Bit-by-bit XOR.

<< doubles, >> halves.

cond ? a : b.

Booleans via stdbool.h.

0 is false, anything else true.

5 > 2 evaluates to 1.

Both must be true.

Either side true.

Returns true / false.

! flips the value.

Compose with &&.

Username + password truthy.

Loop while true.

Run when true.

Two-way branch.

Multiple conditions.

Modulus check.

Compare two ints.

Nested if.

Classic leap-year rule.

Single char branch.

Compact if/else.

Age ≥ 18.

Switch on int.

Switch on letter.

Multiple labels per case.

Switch on operator char.

Multiple cases per branch.

Without break, cases fall.

Catch-all.

Behavior per signal.

Print menu action.

Decode action.

Standard for loop.

Decrement.

Accumulate.

Multiply through.

Print n's table.

Step by 2.

Custom increment.

Print i*i.

From high to low.

Conditional inside loop.

Manual increment.

Stop at threshold.

Repeated mod 10.

Loop while > 0.

Mod-and-divide.

Doubling.

Update two vars.

Loop subtraction.

Up to 1024.

Increment until condition.

do-while basics.

Body executes even if false.

Inclusive end.

Same logic as while.

Add and step.

Step by 2.

Multiply n down to 1.

Always once even for 0.

Decrement.

Until threshold.

5x5 table.

n x n stars.

Increasing stars.

Decreasing stars.

Print numbers.

Aligned stars.

Stars on border only.

Sequential numbers.

Pyramid of digit lines.

Letter pyramid.

Stop the loop when found.

Skip loop body.

Inside while.

Sum positives only.

break on first.

Avoid divide-by-zero.

Use a flag.

Skip in while.

Manual break.

continue inside string traversal.

Static initialiser.

Loop and add.

Sum / count.

Track max.

Track min.

Swap from outside in.

Find a value.

Element-wise copy.

Matrix.

Sort ascending.

%s prints until \0.

Length of string.

Copy a string.

Concatenate strings.

Compare two strings.

In-place swap.

Compare ends inward.

Subtract 32.

Iterate chars.

Loops + index.

scanf with %d.

scanf with %f.

Sum two inputs.

Leading space to skip whitespace.

%s reads to whitespace.

Read entire line.

Use scanf return value.

Variable N items.

Read until EOF.

Parse from a string.

&x is the address of x.

Both side by side.

Bytes of an int.

Differ by sizeof(int).

Contiguous memory.

Dereference via *.

Change value through pointer.

Pass-by-pointer.

Array name decays to pointer.

p+1 advances by sizeof(int).

int *p; *p = 42.

Pass pointers.

Walk via pointer arithmetic.

char* literal.

Return static address.

p++ moves to next int.

Always validate before use.

Pointer to a pointer.

Strings array.

Read-only pointee.

No return value.

add(a, b).

max(a, b, c).

n! = n * (n-1)!.

f(n) = f(n-1)+f(n-2).

Receive size separately.

Modify caller's variable.

Prototype before main.

Persists between calls.

Pass a function as argument.

fopen + fprintf + fclose.

fopen + fgets.

fopen with "a".

fopen returns NULL.

Loop with fgets.

fgetc.

Increment on newline.

Read from one, write to another.

Seek to position.

fwrite / fread.

Brace initialiser.

dot operator.

Skip the struct keyword.

List of records.

Struct in struct.

Use -> to dereference.

By value.

Avoid copy.

Return by value.

Sum of fields (with padding).

Auto-numbered from 0.

Set first, rest follow.

Combine with switch.

Save typing.

Use ==.

Cast iterator.

Stored as int.

Catch unknown.

Use in array.

Mixed values.

malloc + free.

n ints in a row.

Bytes set to 0.

Grow array.

Avoid dangling.

Allocate char buffer.

Always validate.

Array of pointers.

malloc a struct.

Same as malloc.

Check before dividing.

fopen NULL on failure.

1 on success.

Print last system error.

Read errno from <errno.h>.

exit(EXIT_FAILURE).

Crash on bad input (debug).

Avoid dereferencing NULL.

Reject bad input.

Return value from main.

Simple text replace.

Watch parentheses!

Backslash for continuation.

Check if defined.

Define if not already.

Remove a macro.

Turn token to string.

Glue tokens.

Built-in macros.

Generic max.

C ↔ F.

Operate on two numbers.

Bucketed grading.

Compound formula.

Prompt-style.

Struct in action.

First 10.

Trial division.

Classic.

Simple state.

%d %f %s %c.

%x and %o.

printf alignment.

for, while, do-while.

Brace init forms.

strcpy/strcat/strcmp.

Brace + designated.

cond ? a : b.

Forgot include / mismatched format.

Generic helpers.

XOR swap.

Compare pairwise.

Euclid.

a*b / gcd.

Trial up to sqrt.

Iterative.

Reverse and compare.

Sum of cubes.

Classic.

Mod-and-divide.

Push + pop.

Single-linked, allocated.

FIFO.

Stable swap pass.

Pick min each pass.

Build sorted prefix.

Scan until found.

On sorted array.

Two-pointer.

Nested scan.

Math swap.

While loop.

Mod 10.

Build reverse.

Stack of bits.

Pow 2.

Math.

Trial division.

Slow but classic.

Sum of divisors.

++a returns new, a++ returns old.

Bytes per type on this machine.

& gets address.

Persists across calls.

Function copy.

Pointer into caller.

calloc zero-inits.

Pointer immutable, value mutable.

Array decays to pointer.

n disks.