{"@context":"https://schema.org","@graph":[{"@type":"Course","name":"C Programming Fundamentals","description":"Master c with our comprehensive beginner → advanced course. Learn C from the ground up—syntax, memory management, data structures, algorithms, and modern C11/17 features. By the end you’ll be able to write robust, portable, and high‑performance C programs. Perfect for beginner → advanced developers. Duration: 30 hours.","provider":{"@type":"Organization","name":"BraveProgrammer","url":"https://braveprogrammer.vercel.app","logo":{"@type":"ImageObject","url":"https://braveprogrammer.vercel.app/logo.png"}},"educationalLevel":"Beginner → Advanced","inLanguage":"c","timeRequired":"30 hours","hasCourseInstance":{"@type":"CourseInstance","courseMode":"online","instructor":{"@type":"Person","name":"Mohit","jobTitle":"Full Stack Developer","url":"https://braveprogrammer.vercel.app"}},"about":[{"@type":"Thing","name":"What Is C?","description":"C is a **procedural, compiled language** created in the early 1970s. It is the lingua‑franca of system programming, embedded devices, OS kernels, and performance‑critical software.\n\n- Developed by Den..."},{"@type":"Thing","name":"Setting Up a Development Environment","description":"You need a **compiler** (gcc, clang, MSVC) and a **text editor/IDE** (VS Code, CLion, Vim). The typical tool‑chain is:\n1. **Pre‑processor** – expands macros.\n2. **Compiler** – translates source to ass..."},{"@type":"Thing","name":"Basic Syntax & Structure","description":"Every C source file is a collection of **function definitions**. The entry point is `int main(void)` (or `int main(int argc, char *argv[])`).\n\nKey syntax rules:\n- Statements end with a **semicolon** `..."},{"@type":"Thing","name":"Data Types & Sizes","description":"C provides **primitive types** with implementation‑defined size. The `sizeof` operator lets you query the exact size in bytes.\n\n| Category | Types | Typical Size (on 64‑bit) |\n|----------|-------|----..."},{"@type":"Thing","name":"Variables & Constants","description":"Variables store values of a specific type and must be **declared** before use. `const` makes a variable read‑only after initialization.\n\n```c\nint age = 30; // mutable variable\nconst double PI..."},{"@type":"Thing","name":"Operators Overview","description":"C includes arithmetic, relational, logical, bitwise, assignment, and ternary operators.\n\n| Category | Operators |\n|----------|-----------|\n| Arithmetic | `+ - * / %` |\n| Relational | `== != < > <= >=`..."},{"@type":"Thing","name":"Control Flow – if / else","description":"`if` statements execute a block when a condition is true. An optional `else` clause runs when the condition is false.\n\n```c\nif (x > 0) {\n printf(\"positive\\n\");\n} else {\n printf(\"non‑positive\\n\")..."},{"@type":"Thing","name":"Control Flow – switch","description":"`switch` selects among discrete constant values, often used instead of many `if‑else` checks.\n\n```c\nswitch (menu) {\n case 1: printf(\"New Game\\n\"); break;\n case 2: printf(\"Load Game\\n\"); break;\n ..."},{"@type":"Thing","name":"Loops – while & do / while","description":"Loops repeat a block of code while a condition holds.\n\n- `while(condition) { … }` – condition checked **before** each iteration.\n- `do { … } while(condition);` – body executes **at least once** before..."},{"@type":"Thing","name":"Loops – for","description":"`for` is the most common loop for counting.\n\n```c\nfor (int i = 0; i < 10; ++i) {\n printf(\"%d \", i);\n}\n```\n\nThe three parts are:\n1. **initialization** – executed once.\n2. **condition** – evaluated b..."},{"@type":"Thing","name":"Functions – Declaration & Definition","description":"Functions encapsulate reusable code. A **prototype** (declaration) tells the compiler about the function’s name, return type, and parameters before it is used.\n\n```c\n/* Prototype */\nint add(int a, int..."},{"@type":"Thing","name":"Variable Scope & Storage Classes","description":"C defines **storage duration** and **linkage** via storage‑class specifiers.\n\n| Specifier | Description |\n|-----------|-------------|\n| `auto` | Default for local variables (automatic storage). |\n| `s..."},{"@type":"Thing","name":"Pointers – Basics","description":"A **pointer** holds the memory address of another variable.\n\n```c\nint x = 10;\nint *p = &x; // p now points to x\nprintf(\"%d\\n\", *p); // dereference → prints 10\n```\n\nKey concepts:\n* `&` **address‑of**..."},{"@type":"Thing","name":"Pointer Arithmetic","description":"When a pointer points to an element of an **array**, adding or subtracting integers moves it by that many elements, not bytes.\n\n```c\nint arr[5] = {10,20,30,40,50};\nint *p = arr; // same as &arr..."},{"@type":"Thing","name":"Arrays","description":"An **array** is a contiguous block of elements of the same type.\n\n```c\nint numbers[5]; // uninitialized (indeterminate values)\nint initialized[3] = {1,2,3}; // static initialization\nint..."},{"@type":"Thing","name":"Strings – Character Arrays","description":"C does **not** have a built‑in string type. Strings are arrays of `char` terminated by a **null byte** (`'\\0'`).\n\n```c\nchar name[6] = {'J','o','h','n','\\0'}; // explicit\nchar greeting[] = \"Hello\"; ..."},{"@type":"Thing","name":"Dynamic Memory – malloc & free","description":"The **heap** provides memory at runtime via `` functions:\n* `void *malloc(size_t size)` – allocate uninitialized memory.\n* `void *calloc(size_t count, size_t size)` – allocate zero‑initializ..."},{"@type":"Thing","name":"Structures (`struct`)","description":"`struct` groups different data types into a single composite type.\n\n```c\nstruct Point {\n double x;\n double y;\n};\n\nstruct Point p1 = { .x = 3.0, .y = 4.0 };\n```\n\nYou can create **typedefs** for s..."},{"@type":"Thing","name":"Unions","description":"`union` shares the same memory location for all its members. Only **one** member can be active at a time.\n\n```c\nunion Data {\n int i;\n float f;\n char c;\n};\n```..."},{"@type":"Thing","name":"Enumerations (`enum`)","description":"`enum` defines a set of named integer constants.\n\n```c\nenum Color { RED, GREEN = 5, BLUE };\n// RED=0, GREEN=5, BLUE=6\n```..."},{"@type":"Thing","name":"Bitwise Operations","description":"Bitwise operators work directly on the binary representation of integers.\n\n| Operator | Meaning |\n|----------|---------|\n| `&` | AND – set bits that are 1 in **both** operands |\n| `|` | OR –..."},{"@type":"Thing","name":"Function Pointers","description":"A **function pointer** stores the address of a function and can be invoked like a regular function.\n\n```c\nint add(int a, int b) { return a + b; }\nint (*op)(int,int) = add; // pointer to function\nprint..."},{"@type":"Thing","name":"Recursive Functions","description":"A function is **recursive** when it calls itself. Each call creates a new **stack frame** with its own local variables.\n\n```c\nint fact(int n) {\n if (n <= 1) return 1;\n return n * fact(n-1);\n}\n``..."},{"@type":"Thing","name":"Standard Input / Output (`stdio.h`)","description":"The `` library provides the core I/O functions.\n\n| Function | Purpose |\n|----------|---------|\n| `printf` | Formatted output to `stdout`. |\n| `scanf` | Formatted input from `stdin`. |\n| `fpri..."},{"@type":"Thing","name":"File I/O (`stdio.h`)","description":"Files are accessed through `FILE*` streams.\n\n```c\nFILE *fp = fopen(\"data.txt\", \"r\");\nif (!fp) { perror(\"open\"); exit(EXIT_FAILURE); }\n\nchar line[128];\nwhile (fgets(line, sizeof line, fp)) {\n // pro..."},{"@type":"Thing","name":"Preprocessor Directives","description":"The **preprocessor** runs before compilation and handles macros, file inclusion, and conditional compilation.\n\n```c\n#define PI 3.14159\n#define SQUARE(x) ((x)*(x))\n\n#if defined(_WIN32)\n #define PLAT..."},{"@type":"Thing","name":"Header Files & Multiple Translation Units","description":"A **translation unit** is a source file after preprocessing. Splitting a project into multiple `.c` files improves modularity.\n\nTypical layout:\n```\nproject/\n├─ src/\n│ ├─ main.c // contains ..."},{"@type":"Thing","name":"Makefiles – Building Large Projects","description":"A **Makefile** automates compilation, tracks dependencies, and avoids rebuilding unchanged files.\n\nKey concepts:\n* **Targets** – file to be generated (`myprog`).\n* **Prerequisites** – files the target..."},{"@type":"Thing","name":"Dynamic Data Structures – Linked List","description":"A singly linked list stores nodes that contain **data** and a **pointer** to the next node.\n\n```c\nstruct Node {\n int data;\n struct Node *next;\n};\n```\n\nOperations:\n* **Insert** at head – O(1).\n* ..."},{"@type":"Thing","name":"Dynamic Data Structures – Doubly Linked List","description":"A **doubly linked list** stores two pointers per node – `next` and `prev`. This allows O(1) deletion and reverse traversal.\n\n```c\nstruct DNode {\n int data;\n struct DNode *prev;\n struct DNode ..."},{"@type":"Thing","name":"Stacks (LIFO) Using Arrays","description":"A **stack** follows *last‑in‑first‑out* order. Implemented easily with a fixed‑size array and an integer index.\n\n```c\n#define MAX 100\nint stack[MAX];\nint top = -1; // empty stack\n\nvoid push(int x) { i..."},{"@type":"Thing","name":"Queues (FIFO) Using Circular Buffers","description":"A **queue** follows *first‑in‑first‑out*. A circular buffer efficiently implements a fixed‑size queue without moving elements.\n\n```c\n#define CAP 5\nint q[CAP];\nint front = 0, rear = 0, size = 0;\n\nint e..."},{"@type":"Thing","name":"Binary Trees – Basic Operations","description":"A **binary tree** node has at most two children: `left` and `right`. A common use is a **binary search tree (BST)** where left < node < right, enabling O(log n) lookup on average.\n\n```c\nstruct TreeNod..."},{"@type":"Thing","name":"Sorting Algorithms – Bubble, Selection, Insertion","description":"Sorting puts data into a defined order. Below are three classic O(n²) algorithms, good for learning fundamentals.\n\n**Bubble Sort** – repeatedly swap adjacent out‑of‑order elements.\n**Selection Sort** ..."},{"@type":"Thing","name":"Sorting Algorithms – QuickSort & MergeSort","description":"Both **QuickSort** and **MergeSort** achieve O(n log n) average performance.\n\n* **QuickSort** – partition array around a pivot, then recursively sort partitions. In‑place, but worst‑case O(n²) if pivo..."},{"@type":"Thing","name":"Searching Algorithms – Linear & Binary Search","description":"Search for a target value in a collection.\n\n* **Linear Search** – scan each element sequentially – O(n).\n* **Binary Search** – works on **sorted** arrays – repeatedly halve the search interval – O(log..."},{"@type":"Thing","name":"Bit Manipulation Techniques","description":"Bit tricks are useful for flags, fast arithmetic, and low‑level protocols.\n\n| Task | Expression |\n|------|------------|\n| Set bit `n` | `x |= (1U << n);` |\n| Clear bit `n` | `x &= ~(1U << n);`..."},{"@type":"Thing","name":"Dynamic Memory – Reallocating Arrays","description":"`realloc` changes the size of an existing allocation while preserving its content.\n\n```c\nint *arr = malloc(5 * sizeof *arr);\n/* ... fill ... */\narr = realloc(arr, 10 * sizeof *arr); // grow to 10 elem..."},{"@type":"Thing","name":"C11 & C17 Modern Features","description":"The C language evolves. Modern standards add safety, concurrency, and convenience.\n\n| Feature | Header | Usage |\n|---------|--------|-------|\n| `_Static_assert` | `` | Compile‑time assertion..."},{"@type":"Thing","name":"Multithreading with `` (C11)","description":"C11 introduced a **portable threading API**: `thrd_t`, `mtx_t`, `cnd_t` etc., from ``.\n\nTypical workflow:\n1. Create a thread with `thrd_create(&t, func, arg);`.\n2. Wait for it to finish wit..."},{"@type":"Thing","name":"POSIX Threads (`pthread`) – Advanced","description":"On Unix‑like systems the **POSIX thread** library (`pthread`) provides a richer API.\n\nKey components:\n* **Thread creation** – `pthread_create(&tid, NULL, func, arg);`\n* **Joining** – `pthread_join(tid..."},{"@type":"Thing","name":"Signal Handling (`signal.h`)","description":"Signals are asynchronous notifications (e.g., `SIGINT`, `SIGTERM`). Use `signal` or the more robust `sigaction` to install handlers.\n\n```c\n#include \n#include \n#include \n\nv..."},{"@type":"Thing","name":"File I/O – Binary Files","description":"Binary files store raw bytes without newline translation.\n\n```c\nFILE *fp = fopen(\"data.bin\", \"wb\");\nint vals[5] = {10,20,30,40,50};\nfwrite(vals, sizeof vals, 1, fp);\nfclose(fp);\n```\n\nReading:\n```c\nFIL..."},{"@type":"Thing","name":"Error Handling – `errno` & `perror`","description":"`errno` (declared in ``) holds the **error code** from the last library call that set it. Functions like `strerror` translate it to a readable string.\n\n```c\nFILE *fp = fopen(\"missing.txt\", \"r..."},{"@type":"Thing","name":"Debugging with GDB","description":"The GNU Debugger (`gdb`) lets you step through code, inspect variables, and set breakpoints.\n\nTypical workflow:\n1. Compile with `-g` flag to embed debug symbols.\n2. Start debugging: `gdb ./a.out`.\n3. ..."},{"@type":"Thing","name":"Unit Testing with CMocka","description":"CMocka is a lightweight unit‑testing framework for C.\n\n1. Install via package manager (`apt-get install libcmocka-dev`).\n2. Write test functions returning `void`.\n3. Use `assert_int_equal`, `assert_st..."},{"@type":"Thing","name":"Static Analysis with clang‑tidy","description":"`clang‑tidy` is a **linter** that checks C code for bugs, style, and modern practices.\n\nCommon checks:\n* `readability-identifier-naming` – enforce naming conventions.\n* `modernize-use-nullptr` – (C++)..."},{"@type":"Thing","name":"Memory Debugging with Valgrind","description":"Valgrind detects **memory leaks**, **invalid reads/writes**, and **use‑after‑free**.\n\nTypical usage:\n```bash\nvalgrind --leak-check=full ./myprog arg1 arg2\n```\nOutput includes:\n* **Invalid read/write**..."},{"@type":"Thing","name":"Cross‑Compilation – Building for Embedded Targets","description":"Cross‑compilation allows you to build a binary on a host machine for a **different architecture** (e.g., ARM Cortex‑M, AVR).\n\nTypical toolchain prefix: `arm-none-eabi-` or `avr-`.\n\n```bash\narm-none-ea..."},{"@type":"Thing","name":"Best Practices & Coding Style for C","description":"Consistent style makes code readable and maintainable.\n\n#### 📋 Recommended Style Guidelines\n* **Naming** – `snake_case` for variables/functions, `PascalCase` for types.\n* **Brace placement** – K&R or..."}],"teaches":["C is a compiled, procedural language.","Provides direct memory access via pointers.","Highly portable – the same source can compile on many platforms.","Forms the foundation for many modern languages.","Choose a compiler: gcc, clang, or MSVC.","IDE options: VS Code (free), CLion (paid), vim/emacs.","Typical compile command: `gcc -Wall -Wextra -o prog prog.c`.","Verify installation with `gcc --version` or `clang --version`.","Every program must have a `main` function.","Statements end with a semicolon.","Curly braces define a block scope.","Two comment styles: // and /* */.","`sizeof` returns the size of a type or variable in bytes.","`int` is usually 4 bytes on modern platforms.","Use `` for portable fixed‑width integers.","`float` (single‑precision) ≈ 7 decimal digits; `double` ≈ 15.","Declare a variable: ` = ;`","`const` qualifies a variable as read‑only.","Uninitialized variables contain **indeterminate** (garbage) values.","Scope is determined by the block (`{}`) where the variable is declared.","Arithmetic operators work on integer and floating types.","Logical operators return true (1) or false (0).","Bitwise operators manipulate individual bits.","`=` is assignment; `==` is equality comparison.","Ternary `? :` is a compact conditional expression.","`if (condition) statement;` – condition must evaluate to non‑zero for true.","`else` runs when the `if` condition is false.","Multiple `else if` branches can be chained.","Always use braces `{}` to avoid dangling‑else bugs.","`case` labels must be **integral constant expressions**.","`break` prevents fall‑through to the next case.","`default` handles all unmatched values (optional).","Fall‑through can be useful; mark it with a comment for clarity.","`while` checks the condition first; if false, body never runs.","`do…while` runs the body once then checks the condition.","Always ensure the loop modifies something that will eventually make the condition false.","Use `break` to exit early; `continue` skips to the next iteration.","`for(init; condition; increment)` is syntactic sugar for a `while` loop.","All three parts are optional – `for(;;)` creates an infinite loop.","Scope of the loop variable (`int i`) is limited to the loop block (C99+).","Use `++i` (prefix) when the value isn’t needed inside the expression for a tiny performance gain.","Return type appears before the function name.","If a prototype is missing, the compiler assumes `int` (pre‑C99) – avoid this.","Parameters are passed **by value** (copies).","`void` as a parameter list means *no arguments*.","`static` inside a function keeps the variable value between calls.","`extern` allows sharing a global variable across multiple `.c` files.","`register` is largely obsolete – the compiler decides register allocation.","Block scope limits a variable to the surrounding `{}`.","`int *p` declares a pointer to an integer.","`&var` yields the address of `var`.","`*p` reads/writes the value stored at the address `p` points to.","Never dereference a `NULL` or uninitialized pointer – you get undefined behavior.","`p + n` moves the pointer `n` elements forward.","Subtracting two pointers yields the number of elements between them.","Pointer arithmetic outside the bounds of an array leads to **undefined behavior**.","`sizeof(*p)` tells you the size of the pointed‑to type.","`int a[10];` allocates space for 10 integers.","Array indices start at **0**.","`sizeof(arr) / sizeof(arr[0])` gives the element count.","Passing an array to a function decays to a pointer (`int *`).","A C‑string ends with a null character `\\0`.","`strlen(s)` returns the length **excluding** the null terminator.","`strcpy` can overflow – prefer `strncpy` with a size argument.","String literals are read‑only; modifying them causes undefined behavior.","`malloc` returns a `void*` – cast to the appropriate pointer type.","If allocation fails, `malloc` returns `NULL`.","Every successful `malloc`/`calloc`/`realloc` must have a matching `free`.","Use tools like **Valgrind** or **AddressSanitizer** to detect leaks.","`struct` creates a new type that can hold heterogeneous members.","Access members with the `.` operator (`structVar.member`).","When you have a `struct *ptr`, use `ptr->member`.","`typedef struct {...} Name;` simplifies usage.","All members occupy the same memory; size = size of largest member.","Useful for type‑punning or interpreting raw bytes.","Reading a member that wasn't most recently written is undefined.","Enum constants are of type `int` unless a different underlying type is forced (C11).","Useful for readable code and `switch` statements.","You can assign explicit values; subsequent values auto‑increment.","`x & 0x1F` extracts the low‑order 5 bits.","`x | 0x80` sets the high bit.","`x ^ y` toggles bits that differ.","`x << 1` is equivalent to `x * 2` for unsigned values.","Declare: `return_type (*ptr_name)(param_types)`.","Assign with the function name **without** parentheses.","Call via `(*ptr)(args)` or simply `ptr(args)`.","Can be stored in arrays for dispatch tables.","Base case prevents infinite recursion.","Each recursive call consumes stack space – watch out for **stack overflow**.","Tail recursion can be optimised by some compilers, but C does not guarantee it.","Recursive solutions are often more readable for tree/graph traversals.","`printf` uses format specifiers (`%d`, `%f`, `%s`, `%p`).","`scanf` can leave the input buffer in an unexpected state – prefer `fgets` + `sscanf`.","`fprintf(stderr, ...)` prints error messages to the standard error stream.","Never forget to `fflush(stdout)` when mixing `printf` with input prompts.","`fopen` returns `NULL` on failure – always test the pointer.","`feof(fp)` tells you when end‑of‑file is reached after a failed read.","`fread`/`fwrite` are binary‑safe; `fgets`/`fprintf` are text‑oriented.","`fflush(fp)` forces buffered data to be written to the file.","`#include ` brings a system header; quotes `\"file.h\"` search local directory first.","`#define` creates a macro; parentheses are essential for function‑like macros.","Conditional compilation (`#ifdef`) allows platform‑specific code.","`#pragma once` or include guards prevent multiple inclusion.","Header files (`.h`) expose **public interfaces**; source files (`.c`) provide implementations.","Include guards (`#ifndef … #define … #endif`) prevent duplicate inclusion.","Separate compilation speeds up builds and enables modular testing.","The linker resolves external symbols from the object files.","`make` decides what needs rebuilding by comparing timestamps.","`$@` – target name; `$^` – all prerequisites; `$<` – first prerequisite.","`.PHONY:` declares non‑file targets to avoid name clashes.","Use `wildcard` and pattern rules to keep the file list dynamic.","Each node holds a value and a pointer to the following node.","`head` points to the first node; `NULL` marks the end.","Always `free` nodes you remove to avoid memory leaks.","Insertion at the front is constant time; searching is linear.","`prev` points to the previous node; `next` to the next.","Head's `prev` and tail's `next` are `NULL`.","Deletion does not need a previous pointer‑search – O(1).","Careful pointer updates avoid dangling links.","`top` index points to the most recent element.","Check for overflow (`top == MAX-1`) before `push`.","Check for underflow (`top == -1`) before `pop`.","Useful for expression evaluation, backtracking, recursion simulation.","`front` points to the first element; `rear` points to the slot where the next element will be inserted.","Modulo operation wraps indices (`% CAP`).","Check `size == CAP` for overflow and `size == 0` for underflow.","Excellent for producer‑consumer problems.","Recursion is natural for tree traversals.","BST property: `left.key < node.key < right.key`.","In‑order traversal yields sorted keys.","Memory allocation for each node via `malloc`.","Bubble Sort: easy to implement, but inefficient – O(n²).","Selection Sort: fewer swaps, still O(n²).","Insertion Sort: good for nearly‑sorted data; O(n²) worst‑case, O(n) best‑case.","All three are in‑place and require only O(1) extra memory.","QuickSort is in‑place but needs good pivot selection (e.g., median‑of‑three).","MergeSort’s extra memory makes it stable and predictable.","Both have O(n log n) average time; recursion depth is O(log n).","Tail‑call optimization can reduce stack usage for QuickSort.","Linear search is simple and works on unsorted data.","Binary search requires sorted input; otherwise result is undefined.","Iterative binary search avoids recursion overhead.","Use `size_t` for array indices to avoid negative values.","Left‑shift `1U << n` creates a mask with only bit `n` set.","`x & (x-1)` clears the lowest set bit – great for counting ones.","Bitwise ops are defined for unsigned types; signed‑right‑shift is implementation‑defined.","Use `U` suffix for **unsigned** literals to avoid sign‑extension surprises.","`realloc(ptr, newSize)` can shrink or grow an allocation.","If `newSize` is 0, behavior is implementation‑defined (often equivalent to `free`).","Always test the return value; on failure the original block is still valid.","Use `size_t` for sizes to avoid signed‑unsigned mismatches.","Use `_Static_assert` for **compile‑time** sanity checks.","`_Thread_local` creates variables that are unique per thread – essential for multithreaded code.","Atomic types (`atomic_int`) avoid data races without mutexes.","`alignas` lets you request stricter alignment for structures that map hardware registers.","`thrd_create` starts a new thread; the thread function must match `int (*)(void *)`.","`mtx_t` is a mutex; always initialise before use and destroy with `mtx_destroy`.","`cnd_t` implements condition variables for signalling.","Thread‑local storage (`_Thread_local`) can avoid mutexes for per‑thread data.","`pthread_create` needs a `void *(*)(void *)` function pointer.","Always unlock a mutex, even on error paths – consider `pthread_cleanup_push` or `pthread_mutex_unlock` in a `finally`‑like block.","`pthread_cond_wait` atomically releases the mutex and waits.","Detach a thread (`pthread_detach`) when you don’t need to `join` it.","`signal` is simple but has portability quirks; `sigaction` is the preferred POSIX method.","Do **not** call non‑async‑signal‑safe functions (e.g., `printf`) from a signal handler on strict POSIX systems.","Use `sigemptyset`/`sigaddset` to control which signals are blocked during handler execution.","Handlers can be used for cleanup, graceful shutdown, or to implement timers.","`wb` opens a file for **binary write**, `rb` for binary read.","Binary I/O is fast and preserves exact memory layout (be aware of endianness).","`fwrite`/`fread` return the number of elements successfully processed.","Use `ftell`/`fseek` for random access within the file.","`errno` is thread‑local on modern implementations.","`perror(\"msg\")` prints `: ` to `stderr`.","Clear `errno` with `errno = 0;` before a call if you need to differentiate later errors.","Only check `errno` after a function indicates failure.","Compile with `-g` to generate debugging symbols.","`break` sets a breakpoint; `run` starts execution.","`next` steps over a function, `step` steps into it.","`print` displays the current value of a variable.","`backtrace` (`bt`) shows the stack trace for crashes.","Test functions must be `void` and accept `void **state`.","Use the assertion macros (`assert_*`) to verify expectations.","Link with `-lcmocka` and compile with `-I/usr/include/cmocka` if needed.","Separate test files (`test_*.c`) from production code.","`clang‑tidy` runs **statically** – no execution required.","Integrate into CI pipelines to enforce code quality.","Can auto‑fix many issues with `-fix` flag.","Combine with `clang‑format` for consistent style.","Valgrind works on Linux/macOS (via Homebrew).","`--leak-check=full` gives detailed leak info.","Use `--track-origins=yes` for uninitialized value traces.","Suppressions allow you to ignore intentional leaks (e.g., in third‑party libs).","The **prefix** (`arm-none-eabi-`, `avr-`) selects the target architecture.","A **linker script** tells the linker where each section lives in memory.","`-mcpu` and `-mthumb` (ARM) control instruction set selection.","After building, use a programmer (e.g., `avrdude`, `openocd`) to upload.","Adopt a **style guide** (e.g., Google C Style, Linux Kernel style).","Make all variables `const` when they never change.","Always check the result of library calls (`malloc`, `fopen`, etc.).","Automate formatting (`clang-format`) and linting (`clang‑tidy`).","Document public API in header files using Doxygen‑compatible comments."],"totalCourseTime":"30 hours","coursePrerequisites":"Basic programming knowledge"},{"@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"Courses","item":"https://braveprogrammer.vercel.app/learning"},{"@type":"ListItem","position":2,"name":"C Programming Fundamentals","item":"https://braveprogrammer.vercel.app/learning/c-programming-fundamentals"}]}]}