C Programming

C is a general-purpose procedural programming language created by Dennis Ritchie at Bell Labs in the early 1970s.

Why it matters:

• Very fast and predictable.
• Gives direct control over memory and data layout.
• Portable across many platforms.
• Forms the foundation for many modern systems.

Where it is used:

• Operating systems and kernels
• Embedded firmware and device drivers
• Compilers/interpreters
• Databases and networking libraries
• High-performance system components

#include <stdio.h>

int main(void) {
    printf("Hello, world!\n");
    return 0;
}

Explanation:

• #include <stdio.h> gives access to printf.
• main is the entry point.
• return 0 indicates successful execution.

It provides declarations for standard I/O:

• Output: printf, fprintf, snprintf
• Input: scanf, fscanf, fgets
• Files: FILE, fopen, fread, fwrite, fclose

Without proper declarations, type checking is weaker and bugs become easier.

• Declaration: tells compiler a name/type exists.
  • Example: int add(int, int);
• Definition: creates storage or function body.
  • Example: int counter = 0;
  • Example: int add(int a, int b) { return a + b; }

Rule of thumb: every definition is a declaration, but not every declaration is a definition.

• char: small integer, often for text bytes
• int: natural integer size
• float, double: fractional values
• void: no value / generic pointer base

Useful modifiers:

• short, long, long long
• signed, unsigned

When exact width matters, use <stdint.h> types like int32_t, uint64_t.

if (x > 0) { ... } else { ... }

for (int i = 0; i < n; i++) { ... }
while (cond) { ... }
do { ... } while (cond);

• if/else: choose one branch.
• for: best when iteration count is known.
• while: loop while condition remains true.
• do...while: executes at least once.

• = assigns value.
• == compares values.

Accidental assignment in conditions is a classic bug. Use warnings: -Wall -Wextra -Werror.

Array = contiguous elements of same type.

int a[5] = {1,2,3,4,5};

Important:

• Index starts at 0.
• Valid range is 0..N-1.
• Out-of-bounds access is undefined behavior.

A C string is a char sequence ending with '\0'.

char s[] = "cat";  // {'c','a','t','\0'}

Many string bugs happen when terminator is missing.

A prototype defines function signature before use.

int max(int a, int b);

Benefits:

• type checking
• clearer interfaces
• better modularity across files

sizeof returns bytes of a type/expression.

sizeof(int);
sizeof x;

• Usually compile-time.
• For VLAs, evaluated at runtime.

int *p = malloc(n * sizeof *p);

This avoids mismatches when type changes later. It is safer during refactors.

A null pointer constant meaning “points to no valid object/function.” Used for:

• initialization
• error signaling
• sentinel termination

Allocation can fail. Dereferencing null pointer is undefined behavior.

int *p = malloc(n * sizeof *p);
if (!p) { /* handle error */ }

calloc(count, size):

1. allocates count * size bytes
2. zero-initializes memory

Great for arrays and state structs needing zero start.

If realloc fails, old pointer remains valid. Use temporary variable.

int *tmp = realloc(p, new_n * sizeof *p);
if (tmp) p = tmp;
else { /* handle failure, old p still valid */ }

Yes. It is defined as a no-op.

Freeing same block twice is UB. Can corrupt heap and create security risks.

Automatic local variables have indeterminate values if not initialized. Reading them is often UB. Initialize variables when practical.

• Local: block scope, typically automatic lifetime.
• Global: file scope, static storage duration (whole program life).

Use globals carefully to avoid tight coupling.

Gives static lifetime but keeps local scope. Value persists between function calls.

For functions/globals, gives internal linkage: visible only inside that source file.

Declares symbol defined elsewhere. Used for shared declarations across translation units.

#ifndef MY_H
#define MY_H
/* declarations */
#endif

Prevents duplicate inclusion and redefinition problems.

Common non-standard include-once directive. Simple and widely supported, but guards are most portable.

Signals success to OS. Non-zero usually indicates error.

In main(int argc, char **argv):

• argc = number of arguments
• argv = array of argument strings
• argv[0] usually program name/path

Use strtol, not atoi.

char *end = NULL;
errno = 0;
long v = strtol(s, &end, 10);

Validate:

• end != s
• *end == '\0' (if full parse needed)
• errno != ERANGE

No bounds checking. Unsafe by design. Removed from modern standards.

• scanf: format-driven, easy to misuse.
• fgets: bounded line input, usually safer.

Good pattern: fgets then parse explicitly.

Writing beyond object bounds. Can cause crashes, corruption, vulnerabilities.

snprintf includes destination size. Prevents unbounded writes.

Adds newline. On terminals, often triggers line-buffer flush.

Examples:

• \n newline
• \t tab
• \\ backslash
• \" double quote
• \0 null terminator

• 'A': character constant (integer value)
• "A": string literal ('A', '\0')

No. Writing to it is undefined behavior.

Expresses immutability and prevents accidental writes.

Named integral constants improve readability.

enum Color { RED, GREEN, BLUE };

It is the standard type for sizes/indices and sizeof results.

Signed type for pointer differences in same array object.

Explicit conversion request. Useful but can hide bugs if misused (especially narrowing/sign changes).

Silent sign/width changes can alter logic unexpectedly.

Small integers (char, short) usually promote to int in expressions.

Mixed comparisons may convert signed to unsigned.

int a = -1;
unsigned b = 1;
if (a < b) { /* may be false */ }

• & AND
• | OR
• ^ XOR
• ~ NOT
• << shift left
• >> shift right

Common in flags, protocols, device code.

• Logical: &&, ||, ! (truth values, short-circuit)
• Bitwise: bit-level integer ops

Right side only evaluated if needed.

if (p && p->next) { ... }

Rules for grouping expressions. Still, prefer parentheses for clarity.

Improves readability and avoids maintenance mistakes.

Compact conditional expression.

result = cond ? a : b;

Great for simple value choices.

A variable holding an address.

int x = 10;
int *p = &x;

Pointers enable indirection and efficient interfaces.

• &x → address of x
• *p → value at address in p

Moves in element units, not raw bytes.

int a[3] = {10,20,30};
int *p = a;
p++; // now points to a[1]

Valid only within same array object (or one-past-end).

Related, not identical:

• array often decays to pointer in expressions
• array itself has fixed size and is not assignable

int x = 1;
int *p = &x;
int **pp = &p;

Useful when a function must modify caller pointer.

To allocate/replace caller-owned pointer or linked-list head safely.

For T a[R][C], memory is contiguous row-major.

Not interchangeable:

• int **: pointer to pointer (often non-contiguous rows)
• int (*)[C]: pointer to row of fixed width C

Runtime-sized automatic arrays. Standardized in C99, later optional. Support varies.

Often avoided for portable/safety code due to optional support and stack risk.

Use malloc, calloc, realloc, and release with free.

Losing all references to allocated memory before freeing it.

Pointers to freed/out-of-scope memory.

free(p);
p = NULL;

struct Buf { size_t n; char data[]; };

Last member only; supports variable-size tail payload.

• memcpy: no overlap allowed
• memmove: overlap-safe

<0, 0, >0 based on lexicographic byte comparison.

May not NUL-terminate on truncation and may pad unnecessary zeros.

snprintf(dst, dst_sz, "%s", src);

Or explicit bounded copy with forced terminator.

Thread-local error indicator set by many library/system calls.

Yes, especially for strtol~/~strtod families.

Special int sentinel indicating end-of-file or error in stdio reads.

Must represent all byte values plus EOF.

Text mode may translate newlines on some OSes. Binary mode is raw bytes.

FILE *fp = fopen(path, "rb");
if (!fp) { /* handle */ }

Always check and close on all paths.

I/O can fail partially or fully (permissions, disk full, interruption).

Flushes stdio output buffers to OS handle. Not guaranteed physical disk persistence.

No, undefined behavior in standard C.

• validate count/formats
• parse robustly
• enforce bounds
• provide clear usage/help

Assume failures happen. Validate inputs, check returns, preserve invariants.

• Preconditions: caller requirements
• Postconditions: function guarantees after success

Improves modularity, encapsulation, maintainability, and build organization.

Public declarations:

• exposed types
• constants/macros
• function prototypes
• ownership/contracts docs

Usually avoid. Exception: static inline or macro utilities.

Preserves API/ABI flexibility and encapsulation.

typedef struct Foo Foo;
Foo *foo_create(void);
void foo_destroy(Foo *);

Implementation details stay private in source file.

User data passed through callback chain. Avoids globals and improves reuse.

• explicit arguments
• const-correctness
• documented ownership/lifetime
• clear return conventions

Defines who allocates, who frees, and when transfer happens. Clear ownership prevents leaks/UAF bugs.

Use consistent pairs:

• create/destroy
• new/free
• dup/free
• take/give

Cleanup safe to call multiple times without breaking state.

Avoids accidental reuse and makes repeat cleanup safer.

Special marker for boundary/error/termination (e.g., NULL, -1).

Unexplained literals reduce clarity. Prefer named constants/enums.

struct Point { int x; int y; };
struct Point p = {3, 4};

Groups related fields as one type.

Type aliases improve readability and abstraction.

C is pass-by-value only. Use pointers to allow function to modify caller data.

A source file after preprocessing. Each TU compiles separately, then linker resolves symbols.

1. Preprocessing
2. Compilation
3. Assembling
4. Linking

Undefined behavior means the C standard imposes no requirements on what happens. If your program triggers UB, anything can happen: crash, wrong output, or seemingly correct behavior. Compilers may optimize under the assumption UB never occurs. Examples: out-of-bounds access, signed overflow, use-after-free, unsequenced modifications.

Implementation-defined behavior is behavior where the compiler/platform must choose one valid option and document it. Your program is still valid C, but result may differ across implementations. Examples: size of int, signed integer representation details, right-shift behavior for negative signed integers.

Strict aliasing is an optimization rule: an object should be accessed through a compatible type (with limited exceptions). Violating this rule is UB and may break code under optimization. Portable alternatives for type reinterpretation usually involve memcpy.

volatile tells the compiler that reads/writes to an object are observable side effects and must not be optimized away or merged too aggressively. Typical use: memory-mapped I/O registers, signal-updated flags. It does not make operations atomic or thread-safe.

No. volatile does not provide mutual exclusion, atomicity, or inter-thread ordering guarantees. Use C11 atomics (stdatomic.h), mutexes, condition variables, etc.

Const correctness means using const to express read-only intent and enforce it via the type system. It improves API clarity and catches accidental modification at compile time.

void print_arr(const int *a, size_t n);

• Automatic: usually local variables in a block; lifetime ends when block exits.
• Static: globals and static locals; lifetime is entire program.
• Thread storage (C11): one instance per thread, lifetime of thread.
• Allocated: dynamic memory from malloc/calloc/realloc until free.

• Stack (common implementation): call-frame based, automatic storage, fast allocation/deallocation.
• Heap: dynamic allocation under programmer control (malloc/free), flexible lifetime.

These are implementation concepts, not strict C language terms.

They let you pass behavior as data. Common use: callbacks, plugin-like dispatch, state-machine/action tables.

int add(int a, int b) { return a + b; }
int (*op)(int, int) = add;
int r = op(2, 3);

• Buffer overflow (unchecked copy/format operations)
• Format string bugs (printf(user_input))
• Integer overflow/underflow in size math
• Use-after-free / double-free
• Missing validation and bounds checks
• Ignoring return values from critical APIs

In normal C practice, each externally visible function/object should have one true definition, with matching declarations everywhere. Inconsistency across translation units can cause link/runtime problems and UB.

If declarations disagree (type, qualifiers, parameters, linkage), compiler may emit diagnostics. If not caught, behavior can become undefined at runtime or link time.

A file-scope declaration like int x; (without initializer) is tentative. If no full definition appears in that translation unit, it acts as a definition with zero initialization.

• Internal linkage: symbol visible only inside one translation unit (usually static at file scope).
• External linkage: symbol can be referenced across translation units.

C inline rules differ from C++. Whether a definition emits code depends on inline, extern inline, static inline, and compiler mode. Use one consistent project style to avoid linker surprises.

A strict prototype fully specifies parameter list, e.g. int f(void);. This enables proper type checking at call sites.

Old K&R-style declarations weaken type checking and can hide mismatches. Prefer modern prototypes in all headers and source files.

Effective type governs which lvalue types may legally access stored object bytes. It is central to aliasing rules and optimization assumptions.

Not universally. Some forms are accepted by compilers/extensions, but portability is subtle. For strict portability, prefer memcpy between object representations.

Uninitialized objects have indeterminate values (sometimes trap representations). Using such values in most expressions is UB.

A bit pattern that does not represent a valid value for a type on some implementations. Reading it through that type may trap or be UB.

Struct padding bytes may be uninitialized/indeterminate. Two structs that are logically equal may differ in raw padding bytes, so memcmp can report inequality.

The time interval where an object exists and may be accessed validly. Before lifetime begins or after it ends, access is invalid (often UB).

On success, realloc may move the allocation; only returned pointer is valid. Old pointer becomes invalid. On failure, old pointer remains valid and unchanged.

Pointer provenance is the idea that compilers track which allocation/object a pointer comes from. Invalid casts/arithmetic can lose valid provenance assumptions.

You may form at most one-past-end pointer (not dereferenceable). Going further is UB, even if you do not dereference immediately.

For negative signed values, result is implementation-defined. Do not assume arithmetic shift unless documented for your targets.

For signed integers, shifting into/sign-changing overflow is often UB. Prefer unsigned integers for bit manipulation.

Modern C describes ordering using “sequenced before/after” relations. If side effects are unsequenced relative to each other on same scalar object, UB can occur.

Atomic types from stdatomic.h support atomic reads/writes/RMW operations with selectable memory ordering.

It initializes atomic objects (especially automatic/dynamic storage) in a defined way.

Use when you only need atomicity (no synchronization ordering), e.g., independent counters/statistics.

A release store followed by acquire load of same synchronization variable establishes happens-before. Writes before release become visible after acquire.

It is easiest to reason about and safest for correctness during initial implementation. Relax ordering only when profiling/analysis justifies it.

Concurrent conflicting accesses (at least one write) to same location without synchronization and not all atomic. Data races are UB in C11.

Yes, for simple flag communication with handlers it is the traditional minimal safe type. Keep handler logic minimal.

Generally no. printf is not async-signal-safe.

A reentrant function can be safely interrupted and called again before previous invocation finishes.

A thread-safe component behaves correctly when used concurrently from multiple threads.

• Static linking: library code copied into final executable.
• Dynamic linking: executable references shared libraries loaded at runtime.

ABI (Application Binary Interface) is the low-level binary contract: calling conventions, data layout, symbol naming, alignment, exception/return conventions.

Changing member order/type/padding changes binary layout and may break compatibility with existing binaries.

Visibility controls what symbols a shared library exports. Limiting exports can reduce symbol collisions and sometimes improve load/startup behavior.

A common baseline: -Wall -Wextra -Wpedantic -Wconversion -Wshadow. Tune per codebase; avoid warning fatigue.

Different compilers catch different bugs/warnings and optimize differently. This improves portability and bug detection.

• -O0: easiest debugging, minimal optimization
• -O2: balanced and common production default
• -O3: more aggressive, may increase code size
• -Os: optimize for size

Some UB and timing-sensitive issues appear only under optimization. Both modes give better confidence.

Optimization performed at link stage across translation units for whole-program opportunities.

Compiler uses collected runtime profiles to optimize hot paths, branch layout, and inlining decisions.

Evaluation order is often unspecified in C. Expressions with multiple side effects on same object without sequencing can be UB. Write simpler statements to make ordering explicit.

C11 defines atomics and memory orders to reason about visibility and ordering among threads. Key orders: relaxed, acquire, release, acq_rel, seq_cst.

Signed overflow is UB; compiler assumes it never happens and may remove/transform checks. Use unsigned/wider types or explicit checked arithmetic.

Types may require addresses with specific alignment. Misalignment can hurt performance or fault on some hardware. Use _Alignof, aligned allocation, and alignment-aware layouts.

Compiler inserts padding for alignment between fields and/or at end. This affects binary layout, size, serialization, and memcmp behavior.

• Stick to standard C
• Use stdint.h fixed-width types where appropriate
• Avoid UB/non-portable assumptions
• Isolate platform code behind clear interfaces
• Build/test on multiple targets and compilers

• ASan: invalid memory access, UAF, overflow
• UBSan: undefined behavior checks
• TSan: data-race detection

They turn subtle bugs into actionable failures during tests.

• Macros (#define)
• Conditional compilation (#if/#ifdef)
• Token/string tricks (##, #)

Prefer typed alternatives (enum, static inline) when possible.

Understand linkage, symbol resolution order, static vs extern, archive/shared library resolution, and ODR-like consistency expectations in C projects.

1. Strict warnings
2. Static analysis
3. Unit/integration tests
4. Sanitizers + fuzzing
5. Review for UB/lifetime/concurrency
6. Document contracts/invariants

CPUs predict branch direction to keep pipelines full. Frequent mispredictions cause stalls and reduce performance.

No. Profile first; optimize measured hotspots.

Access patterns with nearby/reused data improve cache hit rates and speed.

• AoS: good for per-object operations
• SoA: often better for SIMD/vectorized or column-style processing

Different threads updating different variables on same cache line trigger heavy coherence traffic.

Separate hot per-thread data onto different cache lines (padding/alignment/layout redesign).

Custom allocator tuned for repeated allocation patterns/sizes, reducing overhead and fragmentation.

Potential speed/control gains vs complexity, maintenance cost, and debugging burden.

Avoid unnecessary data copies between kernel/user/buffers to improve throughput and latency.

Overflow assumptions may let optimizer alter logic incorrectly. Use unsigned or wider arithmetic for defined wrap behavior.

Arithmetic that clamps to min/max on overflow. Useful in DSP/image/signal domains where wraparound is undesirable.

Overflow in count * elem_size can allocate too little memory, causing later buffer overflow.

Typical baseline: strict warnings, stack protector, fortify, PIE, RELRO, NX (toolchain/platform dependent).

Automated randomized/mutated input generation to discover crashes, hangs, and logic flaws.

Fuzzer finds odd inputs; sanitizers make hidden memory/UB issues crash with diagnostics.

Reducing a failing input to the smallest reproducer for faster root-cause debugging.

A test added after fixing a bug to ensure it never returns.

Compare output to approved reference files; useful when output format is stable and intentional.

Given same source, inputs, and toolchain, output binary is identical.

Ensures reproducibility and consistent warnings/performance characteristics over time.

Building on one architecture/OS for another target architecture/OS.

Use explicit encode/decode helpers and byte-order conversion functions; never rely on host layout.

Padding, alignment, ABI, and endianness differences break portability and compatibility.

A defined serialized representation independent of in-memory C layout.

Include version fields, lengths, optional/reserved sections, and clear parsing rules.

Feature-test macros explicitly select API/standard visibility (e.g., POSIX levels), improving portability control.

It simplifies porting, code review, audits, and future maintenance.

Document preconditions, ownership, lifetime, thread safety, errors, side effects, and postconditions.

Return clear status codes; optionally provide detail via out-params, thread-local context, or errno-style mechanisms.

• Fail-fast: detect and stop quickly; great for debugging and invariants.
• Fail-safe: continue safely/degraded for resilience.

Choose based on domain risk and requirements.

Use opaque types, const, restrictive signatures, dedicated handle types, and minimal mutable surface.

qsort comparators must be consistent/transitive. Violations can make sort results undefined or unstable.

return *(int*)a - *(int*)b; // can overflow

Subtraction may overflow signed int, violating comparator contract.

Newest standard with quality-of-life improvements, but compiler/library support is uneven. Adopt incrementally per toolchain matrix.

Only when your supported compilers/platforms fully support them. Otherwise gate features with checks and compatibility layers.

Improve warning hygiene, remove UB-prone idioms, strengthen tests, then enable newer standard gradually in CI and release flows.

Bounds checks, ownership/lifetime, UB hazards, integer math, concurrency, API contracts, error handling, portability, test coverage.

Expert C remains correct under optimization, explicit about contracts/lifetimes, portable, secure-minded, testable, and maintainable over time.