Advanced C Programming

Learn how the #define directive creates named constants and performs text replacement during preprocessing, replacing tokens with defined values like 32.

Learn how function-like macros work by defining a two-argument max macro with #define, and observe the preprocessor expanding max(a,b) by substituting arguments and producing the result at compile time.

Demonstrate how a function-like macro for squaring a number can misbehave due to operator precedence, and show that surrounding arguments with parentheses fixes it while inspecting preprocessor output.

Advanced C programming by learning to define macros at compile time using the -D flag, assigning my_value (e.g., 50) and printing it in a single source file.

Discover predefined macros in C for debugging and versioning, including __LINE__ for line numbers, __FUNCTION__ for function names, and __TIME__, __DATE__, and __COUNTER__ for build data and counts.

Explain how the include directive brings header files like values.h into C programs, centralizing macros such as size and count for consistent cross-file compilation and preprocessor awareness.

Explore how the #if directive and preprocessor macros control feature availability in C, enabling or disabling feature blocks via feature flags and observing the resulting compiled code.

Explore how the #if preprocessor directive interacts with macro definitions versus runtime variables, showing that defining features as global variables does not influence the preprocessor, which runs before compilation.

Explore the structured paradigm of C by detailing subroutines, the main function, and function calls with inputs and returns, illustrated through add and prime examples.

Learn how to define and call a C function, using is_even to test numbers, with function prototype, header, body, and main, then print results for 7 and 120.

Explore how local and global variables differ in scope and lifetime in C, including access rules and the persistence of globals during program execution.

Explore how scope and lifetime determine local versus global variables in C, using an accumulate demo to show persistent totals with static and extern across functions and files.

Explore how the function execution model manages memory and cpu during function calls, detailing text and stack sections, program counter, stack pointer, and stack frames with foo, bar, and main.

See function execution model in action as main calls accumulate with 10, storing locals a, b, c, d, e on the stack and summing them into total, while examining assembly.

Compare iterative and recursive implementations of an accumulate function, illustrating base conditions, stack frame growth, and when segmentation faults occur, with a recommendation to favor iterative solutions when possible.

Analyze the differences between functions and function-like macros defined with #define, covering return types, argument types, preprocessor text replacement, and linker-related conflicts across files.

Compare the performance versus code-size trade-off of function-like macros and functions in C, using a fruit-count example to show macros expand code and functions incur less per-call overhead.

Learn how to use arrays in C, including zero-based indexing and initializing values, then sort and print an integer array in ascending order with nested loops and a swap macro.

Explore how arrays are stored in memory, including global and local arrays, text, data, and stack sections, and how large arrays impact the stack.

Explore how global and local arrays occupy memory, how the size of operator reports bytes, and why fixed sizes and missing boundary checks cause stack smashing risk.

Explore two-dimensional arrays in C by viewing them as arrays of arrays with rows and columns, fixed size, and no runtime resizing, then extend to higher dimensions and memory layout.

Discover real life uses of arrays, from one dimensional arrays for strings and audio signals to two dimensional grayscale images and three dimensional RGB colored images.

Describe a tic tac toe game design in c using a 3x3 playground, two players x and o, and functions for input, judging a winner, rendering board, and main loop.

Implement a 3x3 tic tac toe game in C with a two dimensional array, render the board, validate inputs, and detect a winner by diagonals, rows, or columns.

Explain how pointers hold addresses to variables, how dereferencing and the ampersand operator access and modify memory, and why uninitialized pointers can crash memory.

Explore the tight relationship between arrays and pointers in C, showing how array names act as fixed pointers to the first element and how pointer arithmetic accesses elements.

Explore pointer types, pointer operators, and pointer casting in advanced C programming. See how pointer sizes remain uniform while the type guides arithmetic, increments, and memory access.

Compare pass by value and pass by address in C, showing how function calls affect caller variables using pointers and memory addresses.

Demonstrate pass by value versus pass by address in C by swapping two variables with a swap function using pointers and the address operator.

Explore how function output parameters use pointers to return values, illustrated by a database example that writes the entry count into a pointed variable and returns a status code.

Learn to pass arrays to functions by address and provide the array size for operations like computing an average. Avoid returning local arrays; doing so causes a segmentation fault.

Explore how memory partitions into text, data, stack, and heap, and distinguish static from dynamic allocation. Learn how malloc and free manage heap memory and what causes memory leaks.

Learn how to implement dynamic memory allocation in C to filter an int array with malloc and free, returning a heap-allocated array containing the even numbers and an output size.

This lecture explains how ASCII maps characters to numbers, how characters occupy one byte in memory, and how strings are arrays of characters terminated by a null character.

Explore practical dos and don'ts for strings in C, including pointer versus array semantics, mutating string contents, comparing strings, and handling string literals in read-only memory.

Explore four standard string manipulation functions—str length, str copy, str compare, and str cat—using string.h to count, copy, compare, and concatenate strings.

Explore advanced pointer topics, including pointer to pointer, array of pointers, and pointer to function, and learn how addresses, indirection, and memory layout affect C programs.

Learn how a C program captures command line input arguments using argc and argv, looping through the argument vector to print each string, including the program name.

Explore modeling complex data in C with structures, defining a car struct with owner name, plate number, and fines; access members via the dot operator and compare to arrays.

Learn to pass and return C structures by value or by reference, using pointers and the arrow operator to modify a car's fines, and implement a function returning a struct.

Learn to create and initialize an array of structures in C with struct car, pass the array to a function, and iterate to print the car type for each element.

Learn pointers to a car structure, access members via the arrow operator, and apply size-based pointer arithmetic (16 bytes) for struct traversal.

Demonstrates modeling a car engine as a nested structure inside a car, with cylinders, capacity, and fuel type, accessed by dot and arrow operators.

Examine structure padding and 32-bit alignment in C, showing how two characters and an int can waste memory, and how pragma pack reduces size by packing to one-byte boundaries.

Design a fixed block size memory manager with init, allocate, and free APIs, compare fixed versus variable block size, and discuss fragmentation and compaction strategies.

Create a memory manager in c with a memory pool and block header, initialize memory, and implement allocate, free, and show stats for debugging blocks.

Develop a reusable input argument parser library in advanced C programming. Implement short and long options (-m/--message, -c/--count) dispatching actions via function pointers, and provide a help flag.

Implement a command line menu project with a root menu, submenus, and actions, using question marks to list options. Track navigation with a menu path array and a current index.

Develop an interactive C menu project with structs for menu items and menus, macros for submenus and actions, and a path-based prompt and input processor to navigate and execute actions.

Improve a C menu program by coloring prompts in yellow using ANSI escape codes, then optimize memory with a union to replace dual pointers, reducing footprint and simplifying menu actions.