My dad taught me about pointers using index registers in assembler.

That analogy between memory address and the address of a house is great! I used to make similar comparisons when teaching C to students and it really seemed to help make it click for them.

Dave, i have been coding in C since 1980 and have, many times, tried with variable success to explain pointers to newbies. This video is clearer and more concise then my best efforts. Going forward I'm just going to refer newbies to this. Thanks.

This is the most amazingly coherent, clear and informative explanation of pointers I have seen in 14 years since I started programming in C and C++. This is beyond fantastic omg please continue. :)

Its a great video if you understand pointers but it fails to do the most important part of why people don't understand pointers. People don't understand pointers because they don't understand the problem they are solving. The moment you understand how memory works, how data is stored/loaded in/from memory and what the cpu has to do differently depending on if you call by reference or by value is the moment you get pointers. The real explanation needed is not what pointers are but what problem they solve and why you need them. Back when i was learning C i had a hard time wrapping my head around pointers until one day my boss took an houre to explain the difference. He showed me the assembler output of different scenarios with and without pointers and explained what happened on each line inside the cpu and memory and it just all made sense after that. It's not about what pointers are but what problem they solve and how.

i was a TA for an intro to C class, and the house example was what i used to describe pointers to people really confused about them. glad to see that you are using a similar example here! i feel that the easiest way to describe technical concepts to people who are confused about them(or have no technical experience/knowledge) is to use a real world analogy, even if it oversimplifies what is actually going on. once they understand the analogy and how it relates to the technical concept, then they can get to the nitty gritty of understanding the technical details behind the concept

Hi Dave, I discovered your channel a few days ago and enjoyed some windows related vids; today I wanted to improve my understanding of C pointers and, voila, here you are again! I looked at some other tutorials, but yours is definitely the best! I really love your style! Keep up your great work; it's pure gold! ❤

Wow, 40 years ago I was still programming Fortran and had never heard of object oriented programming. At the time I was designing a production program to run various tests on pacemakers and since all the tests had some shared behavior (like limits checking, saving results to a database, printing results, etc.), I decided to create a large common block array that was indexed by something I called a "test number" then functions could do what they needed with just a test number. One huge advantage was that I could configure what tests to run and what limits to use and units to report with a big constant array at the top of the code. This meant that when a new test specification came out, usually all I had to do was to change the constant array and no code change was required. Later on in my career my SW boss told me I had created Object Oriented Fortran. Interesting - I was just a young "lazy" programmer trying to find a way to do more with less code to develop, debug, and validate. Also, being ADD, my brain worked faster than my fingers.

Wow. This made a whole lot more sense to me by the end. Thanks Dave!

Thanks for making this video! I still remember the exact ‘ahah’ moment (two decades ago in freshman cs) when I grokked c memory (pointers, arrays, structures). Learning how c handles memory really helped me understand how computers work.

Good video, Dave. I also have been working in C/C++ for about 40 years, including work for some notable compiler vendors such as C86, Zortech C++, and GCC (via Cygnus). This was IMO an uncommonly clear and well-organized presentation. Was impressed that you had time to include pointer-to-functions in this 14-minute overview. Perhaps you might have mentioned the precise prototype matching required to do real-world useful work involving pointer-to-functions; and in particular, how judicious use usually warrants declaring a typedef for a particular group of related pointers-to-functions.

Pointers were so logical and intuitive for me. When I was first learning C++ I was coming from having played around with languages that didn't have dynamic allocation, I didn't know what dynamic allocation was at the time but I had been frustrated in numerous projects I had made that I couldn't make new variables at runtime. So when I first read an example of malloc and using a pointer I immediately put down the book (before even reading the explanation of the example) because I had recognized it as the solution to what I had wanted for so long and wrote a linked list (not that I knew that it was a linked list at the time) to verify that it could do exactly what I had hoped it could, and it worked. I was so excited, the possibilities of pointers were limitless in my eyes and I messed around with them for most of the rest of the day. When I finally got back to reading the book that I was using to learn C++ I was a little disappointed to learn that everything I thought I had created to use pointers for was pretty much covered in the next chapter, but I was glad that at least I had understood them well enough that I could correctly extrapolate their uses without knowing much more than that they existed. It also turned out the example was only the first half of the program that only covered allocation, it wasn't until I turned the page to see the deallocation example and read the explanation for it that I realized all the horrors of memory leaks and how many I must have created that day 😉

You can also subtract a end pointer from a start pointer to get the length of data or string. As for void pointer if you use the same format for all your structs then a uin64_t in the beginning can be used to identify the data type.

Thanks! Very Helpful. You explained some things that C++ books that I have read have overlooked. Like ..... The reason why we even need to use pointers to begin with. I hope to see more content like this.

Thanks for this, Dave. I led the way you explained and the examples. I hope this C/C++ videos keep coming :)

I have always struggled with this. Dave, your explanation is the best I've ever heard and it worked for me! Like you say "it clicked"!

Such a good video Dave, straight to the point. much love from Argentina!

Thanks for your programming content! I have been a programmer for a while but nowadays information technology seems much too complex for me. I cannot code for real but I can follow your explanations and understand them. It's just I have problems memorizing them. So I consider your videos a source of sophisticated entertainment.

BYOB - Bring Your Own Bytes?

Let me speak from my heart =) This description was absolutely incredible! I wish I've had it about 5 years ago..

I've been (slowly) learning C as my starting language just for fun. Pointers has given me many headaches and I still can't completely get a picture in my head of how they work. I wish sometimes that they had a special name or different symbol, maybe that would've made it easier. But you mentioned a few things (that I had to listen to 3-4 times) that gave me some better insight, so maybe one day. Thanks!

Thanks for the pointers, Dave!

Thank you so much for putting together such a great video on pointers. I’ve watched it twice and I plan to watch it three or four more times until I understand every single concept of gone over here. The function pointers are still a mystery to me how I would use those affectively

Great video. Straight to the point, easy to follow along.

Very clear introduction to the most important things about pointers. Remember struggling a lot with those when I started using C++.

Dear Dave, you said something really wonderful. When you want to learn C++ or C but your first language is Python, of course, it looks scary. That is what I can hear from a lot of students who are honestly scared to delve into low-level languages and learn how "motor" actually works. Since I am a child of the 80s, my first language was machine code and assembler for 8-bit CPUs. As such, I always try to explain things from that perspective, emphasizing memory and how the CPU "crawls" through it. Thank you for this episode. I truly believe it is important. Greetings from the Netherlands.

one of the best videos on this topic in my opinion. thank you!

Two follow-up tips: The & (address-of operator) is used when you want to turn the address value of something into a pointer. Second, you will sometimes see that asterisk * in different places between the type and the pointer name: e.g. int* a; int * a; int *a; int (*a); ... all of these are exactly the same. The whitespace doesn't mean anything in these examples. That took me forever to understand. Just try to be consistent in code.

Thanks Dave for revising my C concept. Last time when I did was solving exercise of K&R in 1 st year of graduation. Clap for your line "I am not here to sell anything".

I recently started teaching the introduction system's programming course at my university, and this should make for a great review resource going forward, thank you for this and the many great videos!

Thanks Dave!! I am learning C++ and pointers where the most challenging part. This was a great help.

This is really, really helpful. You have a talent for explaining things.

Love this, thanks Dave!

I've been waiting for you to dive into programming like this... Did not disappoint. Bravo 👏👏👏👏

Thanks, Dave! This is what I'm talking about! Coverage of more advanced C/Cpp topics. Please keep up with explaining some applications where the topic-of-the-day is used. I will say again, your knowledge should be memorized in a book. I would buy two!

That's a very nice refresher on pointers. Thank you!

Thank you for such a clear explanation I have a project coming up for implementing data types so this really helps

Excellent! My best saga was creating a pointer to an array of functions (oh what fun) 😆

Awesome !! I now understand pointers better than I ever had. Thanks

Starting with C and fiddling with memory made understanding how more higher level language handle memory / what is passed by reference vs value.

Man, I could have used such a good explanation 30 years ago!! Thank you Dave!

This was good for me thank you Dave

This video is exactly what I was looking for to help me improve my programming skills. Thank you for making it!⭐♥

My experience with pointers came with my first programming being PDP-11 assembly (school) and later 6502. So dealing with them in 'C was very straightforward...after the syntax of course. I say that because your comment about 'decorating the variable' rather than the type, (int* x is not int *x) was my personal stumbling block.

I hit "thumbs up" on the video for the thumbnail alone, lol.

I understood the point of pointers when I tried to access registers in a microcontroller. And to this day it makes the most sense of using them.

I started learning Turbo Pascal in the mid 90s, so for me pointers where never really hard to grasp as TP uses them too. Once you have the concept in your head a pointer to an array of pointers becomes a natural thing to work with. Great video!

Absolutely fascinating video!

That was so good and so well explained 👏❤

Your video encouraged me to Go Pointers again! Thanks!

30 years ago I learned about pointers in C, and I’m grateful for this recap. Some things made more sense even now, after watching this, particularly the double indirection.

Thanks Dave, helpful stuff

There's an audio book coming? Wow! Can't wait! Have the physical book and love it so far, but finding time and mood for sitting down to read on paper is hard.

Picked up writing some code for microcontrollers, my C is a bit rusty so these video's are very welcome.

Very helpful video, thank you!

Master Pointers! I've been waiting for him!

I learnt about pointers in high school. Having programmed in a higher level language for the next decade or so I really never needed them except for knowing they’re really what's used under the hood for all the syntactic sugar I grew accustomed to. What clicked for me was when, trained to use polymorphism I tried to obtain the same result in c++ embedded only to realize you cannot send daya structes of different sizes to same function. Using pointers was the solution for passing different implementations of an interface of varying byte sizes.

[C]lear and straight to the point(er). 🎯

Thank you this really helps me get started with C++ ❤

Great explanation.

Once the light bulb went on in my head, it was mind-blowing. I was obsessed with it for months afterward.

Holy mackrel I don't think I ever rewatched a single video consequtivelt as this. Sir, in 12 minutes, you explained pointers better than my professor in an hour and a half.

This is actually pretty good. Until recently I had also been learning C and while it takes quite a bit longer to become proficient in it than I have, this talk about many pitfalls in that many beginners in that language fall into. While it's not the most convenient language to learn, it's still really useful in giving you an idea about how certain parts of computers work and hopefully let you learn higher level languages as well. I tend to agree that a bottom up learning pattern is better than bottom down, so even if you're not too interested in C, it's still a useful language to know, at least generally, even if you're not proficient in it. A lot of things in Programming are still based on it and it would just be weird if a proper programmer didn't know certain basic things about programming that you learn in C, even if you don't directly need it these days. Keep ad it, I struggled at first too but once you get the hang of it, you'll wonder how you ever had troubles with it. If you're into it, programming can be a great thing, especially for people that like more practical uses of math but also many people in general. It's not nearly as rigid and a lot more creative than many like to think. So even if someone isn't that much into math, it can still be pretty nice to learn and use. Solving some of those problems you'll end up encountering, requires often a lot more than just purely logical, mathematical thinking, even if tends to be the basis of it. There's lots of creativitiy to be found in programming.

Thanks for the pointers.

On the first example, it is important to note the memory address needs to be casted to a byte pointer. When I was learning, this confused me a bit, especially when working with custom types. You can have an entire buffer filled with data which looks random, but if you cast it to the correct type when dereferencing, all values in the custom structure are magically decoded, and it is extremely fast!

This is very helpful. Thank you!

great video; keep them coming

👍👍Thanks Dave!

Legendary explanation.

I love these C episodes!

Great topic, thanks 👍

One extremely important fundamental point that I am very surprised you didn't mention: The reason why pointers have types to begin with. Void pointers (void*) exist because data is inherently typeless. Is the binary number 01001001 11001111 00000000 11111111 an integer or an unsigned integer or 2 shorts or 4 chars? There's no way to know by the data alone. You have to assign meaning to it. Incrementing/decrementing pointers (like `int a = 5; int* ptr = a; a+=1;`) can be confusing at first because the compiler uses the pointer's type to figure out how many bytes to increment/decrement. Incrementing an int pointer by 1 means "move the pointer by the size of one int (4 bytes)", NOT "move the pointer 1 byte". `a += 16;` == "move the pointer by 16 units of its type" == "move the pointer by 16*sizeof(a)_inBytes" == "move the pointer by 16*4 bytes" "Dereferencing a pointer" means to use the memory location that the pointer is storing, **then actually go to that location, returning the value at that location**. Example: int b = 64; int* ptrToB = nullptr; //Declare the pointer, initializing it to a safe NULL (but with pointer type instead of value type). ptrToB = &b; //Reinitialize the pointer. `&b` means "get the memory address of where b is stored". //Compiler determines the memory address of b, so we can't tell what it is without compiling. int valOfB = *ptrToB; //Dereferencing the pointer, which only ever happens after the pointer is declared ***and*** initialized. //valOfB == 64 **Memory is classified in bytes** and not 4-byte ints or 8-byte longs or anything else is because the *hardware itself is only accessible by entire bytes* (this is sometimes untrue, depending on the computer architecture, meaning sometimes the smallest accessible data is 4-bytes (some 32-bit architectures) or even 8-bytes long (some 64-bit architectures), both of them called a *word*). No modern computer can access each individual bit because that would require too much addressing-data. So how do we not waste 7 bits of memory every time we only need a single bit? Modifying individual bits requires pulling in an entire byte, applying bitwise operation(s) to the entire byte, then storing back the entire modified byte. This way, we can store 8 bools in a single byte instead of needing 8 bytes (but you'll always need at least one byte for a single bool). int a = 5; //ints are usually 4 bytes, meaning a=4+1=2^2+2^0 = 00000000 00000000 00000000 00000101 //The OS has allocated 4 contiguous bytes SOMEWHERE in memory to copy the binary version of the # 5 into. //The OS knew it had to allocate EXACTLY 4 bytes and not only 1 or 1,000 bytes because the compiler knows that //ints are 4 bytes. int* ptr = a; //Go to get the BYTE address that the int `a` will start getting read at. Anytime the pointer `ptr` is used in the future, //the compiler and hence the OS knows to read three more bytes after the initial address of `ptr` (4 bytes total). So, **why do we assign types to pointers?** It's NOT to tell the compiler the size of the pointer itself (which is always the same size on a given system, like how an int is always 4 bytes on the same system), BUT IT IS to **let the compiler know how many bytes to read after the pointer's stored location**.

5:41 The -> pointer "dereference operator" is the shorthand variant for (*struct_name).member e.g. (*pHouse).SquareFeet 11:00 Usually when we program in C without classes ,we are using malloc. In C with classes (C++) we use new. Syntactically are both correct but new is safer. 2:58 Hardware registers or memory locations (physical memory locations on a CPU without MPU/MMU) can be accessed using a single line of code like *(byte *)53281 = 0x00;

very good explanation. especially the function pointer part.

great explanation mr. dave

Thanks for this, I always had pointers as something nasty but this video helped me. :D

I once had to create an array of function pointers. I remember nearly going blind with the syntactic gynastics that was required to create the thing and actually use it without leading to memory leaks. That was some 30 years ago, when I was programming embedded systems. Anyways, I strongly agree that mastering pointer syntax is important to improve your code READING skill. Oh, yah, and I heavily commented all that code. I typcially had more comments in my code then code, but I recall going way overboard commenting that code.

Nice one. I found this video easy to grasp

We use pointers for everything at work. I mean EVERYTHING. Network structs? Passed around everywhere as pointers. Passing around random data structures that you don't define until runtime? Void pointers. Needing to access a player and all their information if building video games? Pass around const refs to the player

You look exactly like a person who would teach me about pointers. Just like a Wizard NPC in games.

Thanks alot, sir!

Even though I come from TTL and then Assembly, I’ve always had inordinate amounts of trouble with symbology involving assembler-directives, figuring out other peoples UIs and pointer notation. 😢 Maybe I’ve been living on the ‘Spectrum’ all along 😂 Thanks for the video and clearing up some of the confusion with the notation! 😊

Feels like a PBS documentary. love it.

Excellent tutorial

Your history with C is almost exactly the same as mine. Love C

I got my first taste of this type of pointer use (outside of assembly language) when I had to learn Modula-2. Thankfully it was a realtively small leap from there to using them effectively in C but the pointer declaration and use nomenclature in C was a bit confusing. This was very helpful thanks.

Pointers are one of those things that isn't complicated but sounds complicated because hard to explain

6 years of college working in C++ and i had never even heard about function pointers, thanks for showing me something i didn't even think was possible!

thanks for the pointers dave ;P

good stuff Dave

I love function pointers. I thought that was the coolest shit when I was studying CS in college.

Free the mallocs! Awesome video. Pointers are always misunderstood and often not done properly, they get especially finicky when you start using classes and C++ conventions, like the Trilogy of Evil (Copy, Assignment, Destructor operators) where data inside pointers has to be handled, not just the pointers themselves. One thing I came across was that in classes, you can allocate memory space with malloc, but it will not call the constructor for you. Another thing I've come across a lot when debugging is that people will call delete on the pointer when it's freed, but you also have to set the pointer to null in order to not leak that last bit of memory. One thing that needs to be taught is how to clean up after your allocations (free() and delete/delete[]). I never learned this from three separate classes, until I went for a Game Development degree at Full Sail.

The Commodore 64 screen background colour byte example was brilliant!

THIS. this is the video that FINALLY made it click for me. thank you Dave

We who are about to design and build salute you!

Very well thank you very much Sir!

Beautiful video I enjoyed it a lot

The day I understood pointers was the day I first heard the address -> house analogy. It still took me a while beyond that to really become fluent with actually deploying the C pointer syntax, and longer still to become comfortable with pointer arithmetic.

The 53281 example made me nostalgic. I've only recently started coding in C, but so far pointers have seemed pretty logical to me, maybe because I grew up on constantly referencing specific addresses in memory on the C64.

I come from a C background, and when I started learning Python I thought to myself "What the hell is going on here?! This is crazy!!" 😂