C Pointers
Learn and Master pointers and the art of using them.
In one intense, code-first course you’ll build rock-solid mental models, wield multi-level pointers, function callbacks, void*, and heap safely, then read real kernel source like a pro.
From ‘&’ vs ‘*’ to dodging leaks and dangling pointers, leave with the exact pointer super-powers that separate junior coders from firmware ninjas.
Zero fluff, 100 % hands-on.
Bestseller
Beginner
Intermediate
Last Updated: 14 Mar 2026|
English|
365 day Access.
Includes
~5 hr 15 mins of recorded lectures.
33 Lessons.
Emulator based experiments.
15 downloadable resource.
Notes/Cheat-sheet.
Case studies based on open-source code.
Exercises and Coding Challenges.
Certificate on completion.
What you will learn
Develop mental models for visualizing and reasoning about pointers.
Learn what a pointer fundamentally is and how to imagine its behavior.
Explore the motivations and reasons for using pointers in C programming.
Set up an environment for working with pointers in code.
Master the syntax for declaring and defining pointers.
Grasp the relationship between pointer variables and memory addresses.
Understand the roles of the * (dereference) and & (address-of) operators in relation to pointers.
Work with multi-level pointers and their applications.
Apply multiple * and & operators effectively in code.
Differentiate between pointers to pointers and arrays of pointers.
Identify similarities and differences between arrays and pointers.
Learn about pointers to data and how they reference data with specific types.
Use pointers with structures, including the * (dereference), . (dot), and -> (arrow) operators.
Perform pointer arithmetic and understand its implications.
Comprehend the memory model in relation to pointers and data.
Understand function pointers (callbacks) and their purpose.
Master the syntax for declaring and using function pointers.
Utilize typedef with function pointers for cleaner code.
Implement examples like arrays of function pointers.
Learn about void pointers and their flexibility.
Differentiate between NULL and NULL pointers, including their uses.
Examine real-world examples of void pointers in Linux source code.
Handle dynamic memory allocation using heap, malloc(), and free().
Manage allocation failures and best practices for error handling.
Identify and prevent memory leaks in pointer-based code.
Recognize and avoid dangling pointers.
Understand the risks of double free() and how to prevent them.
Avoid pointer manipulation issues and accessing unowned memory.
Analyze pointers in open-source baremetal code.
Explore pointer usage in FreeRTOS.
Study pointer implementations in Linux source code.
Details of Content
Mental Models, Motivation and Reasoning about pointers
You’ll trade confusion for clarity in under an hour. Instead of dry definitions, you’ll lock in a single, vivid mental image that turns every pointer into something you can literally see on a whiteboard or sketch on a napkin. You’ll discover what a pointer truly is (spoiler: it’s not just “a variable holding an address”), why the Linux kernel, FreeRTOS, Zephyr, and every serious RTOS lean on them like oxygen, and the three everyday firmware disasters that disappear once pointers click. By the end, you’ll explain pointers to a five-year-old!
What to Imagine?
What is a pointer?
Why pointers?
Pointers - Syntax and Code
You’ll fire up a real dev environment in five minutes and start writing pointer code that compiles and runs on your laptop. You’ll declare your first pointer, watch the & operator spit out raw memory addresses, and use * to reach inside that address like a surgeon. By the time you finish, the difference between a pointer variable and the memory it guards will feel as natural as breathing, and you’ll never again mix up “value” versus “address” in your sleep. No slides, no theory—just you, a terminal, and the exact four lines of code that make every kernel tick.
Environment Setup
Declaring|Defining a Pointer
Pointer Variable and Address
* and & in relation to pointer variable
Multi-level Pointers
You’ll level-up from baby steps to ninja territory in one adrenaline-fueled sprint. You’ll chain ** together until you’re juggling triple-star pointers like a circus pro, then watch & peel them back layer by layer. You’ll see why an array name is secretly a pointer, where the two diverge, and how to build an array of pointers that makes qsort() and Linux device tables look trivial. By the final keystroke, you’ll wield “many *s and many &s” without blinking, turn pointer-to-pointer into your secret weapon, and laugh at code that once looked like hieroglyphics, ready to debug any kernel structure on sight.
Use of * and &
Array and Pointers - Similarity and differences
Many *s and Many &s
Pointer to pointer
Array of pointers
Different types of Pointers
Pointer to Data
You’ll step inside actual RAM and treat memory like clay in your hands. You’ll point to ints, floats, and custom structs with surgical precision, then swap the clumsy (*p).field for the sleek p->field arrow that every Linux driver lives by. You’ll stride through arrays with p+1, discover why char* walks one byte at a time while int* leaps four, and sketch the exact memory map that turns a flat address into a living struct. By the end, you’ll read any kernel data structure blindfolded, fix off-by-one bugs before breakfast, and never again wonder “where exactly does this pointer land?
Pointing to data with a Datatype
Pointer to a struct, *, . and ->
Pointer Arithmetic
Memory model and pointer to data
Pointer to code - Function pointers or Callback
You’ll discover exactly what a function pointer is, master its complete syntax, and clean it up with a single typedef. You’ll then build and run a real function-pointer array that stores multiple functions and calls any one by index.
What is a function pointer?
Function pointers syntax
typedef and function pointers
Example - function pointer array
void pointer
You’ll master the shapeshifting void*: what it is, why it exists, and how to wield it safely. You’ll see NULL in action, learn the exact difference between a null pointer and NULL itself, and then dive straight into real Linux kernel code where void* carries structs, buffers, and callbacks across subsystems.
What is a void pointer?
What is NULL and NULL pointer?
void pointers in - Linux source code
Pointers, Dynamic allocation and problems
You’ll master the heap with malloc() and free(), catch allocation failures the moment they happen, hunt down every byte lost to memory leaks, rescue code from dangling pointers, stop double-free crashes cold, and lock out pointer manipulation that wanders into unowned memory.
heap/ malloc() and free()
Allocation failure
Memory Leak
Dangling Pointer
Double free()
pointer manipulation and unowned memory
Open Source code and Pointers
You will examine pointers in Baremetal Code, trace their use in FreeRTOS, and study how they work in Linux.
Baremetal Code
FreeRTOS
Linux
The Design and Deliberation
I am a big believer of mental models and visualisations when it comes to learning technical concepts. This course is deliberately heavy on insight and frameworks of thinking about pointers.
Pointers in C is a straight forward concept but it has earned a reputation for being hard to understand. In my opinion, the problem is - most of those who try and learn pointers don’t understand how and what to imagine and reason based off of.
From the very first lecture, you’ll notice that I explain key concepts with visualisation and mental models along with a hands on experiment to prove the point. The course is loaded with insights that will empower you to your pointers like a pro!
What sets this apart?
Explain what pointer in C is.
Code development without IDE, like how the professionals do it.
Decomposition of code into Assembly to understand the CPU-Memory iterations.
Mental models to aid thinking and reasoning.
A Bottom-Up Approach with the tinge of answering the Whys.
Real and applicable Case study and programming projects
Teach with insights at the CPU level.
Sample Certificate
Earn a certificate for every technical track by completing 95% of the course work.
Instructors
Electrical Engineer holding a Master’s degree in Embedded Systems, with a proven track record at industry giants. At Intel, contributed expertise to Navigation Firmware, Bluetooth Driver development, and RF validation software.
Currently thriving as an Embedded Software Engineer at Google, drove innovation in Firmware development for the Power Management Sub-system on Tensor SoCs (Pixel Phones) and presently advancing system software for the Pixel Watch.
Audience
Students in Academia with C as a subject in the course.
Those using the C language for development (Embedded Systems Engineers, System Software Engineers etc).
Embedded systems or Firmware Engineers.
Anyone seeking gain system level insights.
Anyone curious to learn the underlying details of Systems and how to program it using pointers.
Requirements
GitHub account to do the hands-on coding in Codespaces.
Some familiarity with the C programming language.
Interest in mastering the concept of Pointers.
FAQs
What is the difference between these courses (paid) and the content on YouTube?
Some lectures from different courses have been put on YouTube as Preview. The are not structured and jump to a topic. The Courses in the Subscription are well structured and focused on developing a skill.
Is this recommended for beginners?
Yes! The courses are taught as if the learner has no idea about the subject. Each course starts of by ensuring that the basics needed to understand the followup lectures is understood.
Why a subscription model?
We are billed for the hosting and bandwidth by the platform provider. While we would very much like to offer lifetime validity, given the recurring bills, we have to ensure we continue to earn enough to be able to fund the effort and bring more value to our learners. The Monthly plan is for those who cannot afford the yearly subscription but can benefit from burst learning. To get the most out of our content, we recommend subscribing to the yearly plan.
Do I need a special machine configuration to take this course?
No! All you will need is an internet connection and the Chrome browser. The hands-on examples and lab work is based on GitHub codespaces platform. We use GitHub Codespace to ensure that you don’t struggle with the setup and focus on the learnings. You are always free to setup the environment locally. Although, we won’t support that, but you are free to do so. The courses, as much possible use a Emulator target of a real board, so if you wanted to run the code on real board. You can do so.
Why is a GitHub account needed?
The Experiments and Labs are based on the GitHub provided Codespaces virtual machine. Codespaces will enable a common work environment for all the learners and avoid the hassle of special setup.
Can I change my email-id post purchase?
As much as we’d like to support that, your account will be linked to your email-id post purchase.
What name will be printed on the Certificate?
The name you use on the platform will be printed as is on the Certificate when it is generated.
Can I follow the steps on my own PC?
Yes for the most part. Better yet would be if you have a linux machine.
I previously purchased a course from inpyjama/pyjamabrah, any discount for me?
Yes. We can offer a discount on the yearly subscription. Please reach us at support@pyjamacafe.com and be sure to include the details of your past investment. We will work on a custom discount for you.
Bestseller
Beginner
Intermediate