you will never ask about pointers again after watching this video
Vložit
- čas přidán 18. 06. 2022
- One of the hardest things for new programmers to learn is pointers. Whether its single use pointers, pointers to other pointers, pointers to structures, something about the concept drives new programmers crazy. The C programming languages is recognized as one of the most difficult programming languages to learn. The reason for this is the limitless power you have over memory management, which comes from pointers.
In this video, I show you what a pointer is, as it applies to low level memory access. Also, we talk about pointer syntax in C and how you can better understand the pointer syntax by converting it to English. And we wrap the video up by asking "why do we care?".
🏫 COURSES 🏫 Learn to code in C at lowlevel.academy
📰 NEWSLETTER 📰 Sign up for our newsletter at mailchi.mp/lowlevel/the-low-down
🙌 SUPPORT THE CHANNEL 🙌 Become a Low Level Associate and support the channel at / lowlevellearning
Why Are Switch Statements so HECKIN fast? • why are switch stateme...
Why Do Header Files Exist? • why do header files ev...
How Does Return Work? • do you know how "retur...
🛒 GREAT BOOKS FOR THE LOWEST LEVEL🛒
C Programming Language, 2nd Edition: amzn.to/3OKh3q2
Computer Systems: A Programmer's Perspective: amzn.to/3N3PqHe
Blue Fox: Arm Assembly Internals and Reverse Engineering: amzn.to/4394t87
Practical Reverse Engineering: x86, x64, ARM, Windows Kernel, Reversing Tools, and Obfuscation : amzn.to/3C1z4sk
Practical Malware Analysis: The Hands-On Guide to Dissecting Malicious Software : amzn.to/3C1daFy
The Ghidra Book: The Definitive Guide: amzn.to/3WC2Vkg
🔥🔥🔥 SOCIALS 🔥🔥🔥
Low Level Merch!: www.linktr.ee/lowlevellearning
Follow me on Twitter: / lowlevellearni1
Follow me on Twitch: / lowlevellearning
Join me on Discord!: / discord - Věda a technologie
come learn to code in C @ lowlevel.academy 😎
It's easy. Just add or remove asterisks or ampersands until it works.
Working with pointers is easy af... Just try different permutation and combinations of & and * until code works like u wanted it to work... Don't complicate easy things.. xD 😁😁
Next thing you know it, you created a buffer overflow attack
@@tenseikenzx-3559 And that's why we use Rust
This is wrong in so many levels 😂
Me after 20 minutes of compile time errors:
__asm__
{
MOV DWORD PTR [0xDEADBEEF],%EAX
}
@@dakata2416 no. that's why we use unique_ptr or shared_ptr.
C++ was the first language I learned.. and I only spent a short time with it. But one thing that made all the difference was having a mental model of computer's memory with addresses and values. Before I knew to do that, C++ was incredibly frustrating. This video is smart to lead with that lesson.
Any resources on learning how computers handle memory?
@@imt3206 If you want to learn the basics, you could learn about Stacks first: en.wikipedia.org/wiki/Stack_(abstract_data_type)
All programs use one or multiple stacks. Functions are called using the stack. While the actual implementation (if you want to write an operating system) is complicated, it will still be usefull to learn this stack model, if you want to get started with coding.
Same, I taught myself C++ well over a decade ago at the wee age of 12 and it took me near 2 years to get pointers. I remember what finally made it click was an analogy comparing it to actual mail addresses, will never forget that enlightening moment.
@@imt3206 in my case, learning how computers handle memory is automatic with learning pointers and data structures like array, stack, qeue, linked list. especially linked list, that shit opened my eyes how linked list is so much superior than array in most cases
czcams.com/users/shorts2YCtH5_56po?feature=share
One important clarification. The asterisk(*) is an attribute of the variable not the type which your explanation seems to suggest. This distinction is important because if you consider the following line:
int* x, y;
x is a pointer to an int while y is just an int. If you wanted both to be pointers you would need to write something like:
int *x, *y;
So i should do int **pX; instead of int** pX; as a good habbit
@@FriedMonkey362 yes
@@FriedMonkey362 It's up to you. That is how I prefer it as I feel it more accurately reflects the syntax, but Strourstrup (founder of C++) actually prefers it *int* pX;*. There is not "right" way per say, so do what you think makes sense : )
That makes sense : *pX (value pointed by pX) is, indeed, an int.
but int * x, y; is just a syntactic sugar to condense on one line this:
int * x;
int y;
during declaration phase the * operator is treated like the type of memory you'll allocate, otherwise it becomes a unary operator to dereference pointers.
so when you declare variables it actually makes sense to read "int * x" as "x is a pointer to int" and otherwise, seeing "*x = y" as "assign y to the address pointed by x"
I'm a senior majoring in Computer Science at college. If you're a young person whose looking to learn about programming and computers, keep watching this guy's stuff! All complex systems can be broken down to simpler parts. That's what this channel does very well when explaining complex concepts like pointers. This is the first video I've seen but I'm definitely subbing cuz this guy not only knows his stuff but more than I do!
My college experience was incredibly lacking in low level courses, which I imagine will be the case at many other universities in the coming future. High-level problem solving has it's place, but low-level is important because a house won't last without a proper foundation. The foundations of computer science are the most important area to master, arguably more important than programming itself.
Don't be a cog; be the future.
What programming languages were pushed at your college? My college is pushing C++ right out of the gate and forces us to learn Assembly as well. Is your college similar?
love this
@@coolperson4582 What college? You're lucky, enjoy!
@@coolperson4582 You are so lucky, my university enforces java and eclipse. It feels like oracle is lobbying there.
@@coolperson4582assembly in 2024?
Understanding references, pointers, smart pointers and memory is gamechanger and is crucial thing to know. Dont give up trying to understand, it is well worth it and with bit of practice becomes normal to read and understand.
I regret giving up programming because of this at school, it would have boosted my career as software engineer forward by years had i put more time into it.
But can’t find practice problems online. So far being working with this company for about 7 months and everywhere in the codebase we use pointers and I just get more confused especially when a pointer or reference is passed to a method and returned from a method
@@abdiasisibrahim5903 best practice i got was when i tried to make my own simple tile based farming game, so i suggest trying to create something of your own, and when problems arise you need to understand and solve them.
I didnt ever finish it, so i cant really show how code looks like, but one of many problems i had was how to grow plants, which I resolved by creating timer, to which I subscribed selected plants and called grow method on them when timer said it is time. Problem also included how to unsubscibe them correctly.
Another issue arised when my game grew too much and I had to split it in smaller modules, so eventually I needed to separate drawing routines from game logic. I remember it being tricky, as my game directly extended from engine.
I stored tiles and other assets in raw arrays stored at heap, so it also needed some thought to put into.
Such practice directly tests your knowledge and teaches you a bit about design patterns and how memory and language works.
Making game trainers is a great way to learn about pointers
@@zanityplays how do you make game trainer (sorry I’m not a gamer)?
@@abdiasisibrahim5903 you use a memory searching tool such as cheat engine to find interesting in game stuff such as player health, some debuggers also have this functionality. Then use relevant os APIs to retrieve a handle to the process and modify data at the found addresses
Video idea: How malloc() works and how does it know what memory is considered "free to use". I started programming on retro game consoles where you know ahead of time exactly how much RAM you have at your disposal, so allocation functions in general are very "alien" to me.
malloc doesn't know. The OS knows.
I figured as much since MS-DOS had a "malloc" feature where you would tell it how much menory you needed and DOS would tell you where it is. But how does the OS know then?
it probably uses mmap or sbrk
@@williamdrum9899 Why wouldn't the os know? That's one of the core functionalities an os provides
@@williamdrum9899 it's still the same on any OS if I'm not mitaken.
The OS has a map of available memory blocks allocated to your program (called pages). When you call malloc, which is a system call, the OS finds a contiguous space of memory allocated to your program where the size you asked for would fit. If not enough memory is available in your page, a new page is allocated to your program.
3 min in and I straight up subscribed. The code translation into english is exactly what makes this so easy to learn.
Thanks a lot.
I struggled quit a bit with pointers and references back when I was learning C (my first programming language,) but I did not gave up and eventually managed to understand them. They're so simple, yet so powerful, and open up an almost infinite number of possibilities. Sometimes, I managed to break programs when using pointers, but in general I have no problem using them 😄
I really lost hope to learn the .. i do find mathematics and electronics are more easy 🤦♂️🤦♂️
The best tutorial so far. This is what high lever languages do all the time with "references" which is just a pointer bound to a value but you cant play with the pointer directly only the value he is pointing too.
I’ve been programming for years and I still feel like this video flipped a switch in my brain. Excellent, I’m going to bookmark this
Understanding isnt hard, applying it cleanly is. Working by bypassing scope might be faster but the need of keeping track of it is hard lest one gets memory leak. Not to mention in bigger teams having to rely on coworkers to apply it cleanly. It becomes a cascading problem with less avenues to debug such bugs.
edit: 1yr on seems my post got some traction, I want to add something. One of many uses and evolution of a Computer is to be a better Calculator. To that end, computers must be able to provide to a user mildly complex logical constructs/objects on which mathematics can be applied and work on them e.g. plus symbol signifying Concatenation of String objects. One should be able to develop some function without having to think of this and that memory allocation. Usage of pointers should only be approached by the top 1 percentile of experienced devs who is probably designing a solution for other devs; or embedded devs having to work with low level resources but won't have a cascading problem.
That's why we practice! :D
@@chudchadanstud then don't put noobs on your dev team
@@_khaine You can put me on your dev team
@@chudchadanstud not naive at all
Exactly, all these videos explain the concept well, but the real problem is when you are coding something and you dont really understand why you need to use a pointer
I don’t fully understand everything, but you make me feel like I will one day…and that’s the most important thing I enjoy the most! It’s all about the journey of learning and not always to the final destination! Thank you for this content!
How is it going man?
i actually appreciated pointers more when i started to learn golang! it really helps especially when you don't always want to expect a return type when making a function and just modify a value that you pass into
Yes, that's called passing by reference, and it's a very useful feature in many languages to save function call overhead and to return multiple results from a function.
Yep! Acknowledging the difference between pass-by-value and pass-by-reference is quite important, and it helps a lot to deeper understand a language.
One decent example can be seen in Visual Basic (just the first one that came to mind), where a methods are assigned a role: either a subroutine (no return value) or a function (has a return value). The function/subroutine parameters can also be prefixed with “ByVal” or “ByRef” depending on what you are going to do with those arguments. It’s quite flexible, but sometimes a bit difficult for some to understand
yep, Go is awesome
@@gg-gn3re I wholeheartedly agree :)
About to finish my computer science degree, and I never really understood pointers because most modern languages abstract this. It's nice to make a full circle though.
Thanks!
this actually answered basically all of my questions regarding pointers and explained them well
The thing that was the most confusing for me was the syntax and all of it clicked when you simply explained that the star is used for two different things. I just couldn't understand why star next to type is a pointer but star next to variable is a value under the pointer
" star next to type is a pointer but star next to variable is a value under the pointer"..
Exactly! I think most tutorials seem to fixate on the memory map element of pointers, which imo isn't that hard to understand. It's the subtly contradictory notation that's that actual source of confusion for most.
Yea, assigning too many uses to the same symbol creates confusion. The concept is easy enough to understand, the grammar is not.
I first learned about pointers while trying to make Whack-A-Mole with an Arduino. I wanted to pass a “mole” struct into a void function to mutate it, but couldn’t figure out why it wasn’t working… wish I’d seen this video back then; it would’ve saved me several hours of confused googling lol
I’ve never really used C so i’m more familiar with the newer languages masking this functionality. Listening to this video is really easy to absorb. Honestly if you can show more examples of pointers in a part 2 i think someone could really solidify the knowledge quickly!
dog
@@danielacevedo7539 ong dog fr slay kween
Thank you for the explanation! Pointers took me about two years to be able to use them, but I legit just never understood why, other than that we could manually delete them as needed. Never understood why my code would work or not work with or without pointers, but understanding the static and dynamic part really helps
Honestly the best video I have ever seen on the pointers. Great work!
I really understood pointers when I got into embedded programming, where you have to access builtin memory address (registers), read their state or write to them. But wait until you get into typecasting pointers, that gets really fun.
every variable can be a char array if you're brave enough.
@@SoulSukkur you can swap bytes by casting variables into char arrays
And also doing dangerous thing like this is allowed in embedded C bare metal. pointing to random memory.
uint32_t *random_mem = (uint32_t*)0x200800FF;
*random_mem = 0xEF; //cause weird behaviour or hardfault.
Great explanation, i think the reason why pointers are so widely misunderstood or hardly understood is the lack of explanation regarding memory layout (which you explained really well) and the not so intuitive syntax
Glad it was helpful!
@@LowLevelLearning umh, not to shoot you down or anything, but if i were being honest, this was like basic stuff. it's fine. the real problem i face is with 2D arrays, and passing them to functions.
the one you explained was just plain variables - it was not at all hard for me. even 1d array is managable, but i can never get pointers to work with 2d arrays, and i thought u'd cover those too....
@@yash1152 Well arrays decay to pointers but it's only the top declarator that does so. A 2d array hence decays to T(*)[N]
you single handedly solved all my confusion. you are a godsend. thank you.
This is a beautiful video my friend! I sorta got the concept, but this! This video helped me COMPREHEND it!
The
int *
can be looked at as the type - it's a pointer to an address space sized to fit an int; bear in mind that different machines or different compilers/options can have different size ints, and declaring that size will let the compiler generate binaries allocating the right number of bits of memory.
this comment touches on something i REALLY hate about C. as far as I'm concerned, char is a fundamentally different type to an char*. which, it is. they're a different size and everything. so WHY can we write declarations like "char a, *b;" creating two variables of fundamentally different types in the same statement? it's stupid and i hate it.
@@SoulSukkur back in the old days people couldn't type very well. And monitors were very low resolution, limiting the number of characters and lines visible. So characters had to be conserved.
@@SoulSukkur nobody is forcing you to write it like that
@@SoulSukkur i just don’t use multiple-declarations, they are already ugly by themselves.
Great video, but I think it required more examples of the applications of pointers. Beginners tend to have a small scope of the concept of pointers with a simple explanation. But honestly to me, pointers can never be explained. Its concept and applications can only be truly understood once we've experimented with it hahaha.
Noted!
It's C's equivalent of "no one can explain what a monad is"
Exactly. All I need is to see use cases.
Basically if you want to pass a huge struct to a function , instead of copying the whole thing in (ie via the copy by value parameter), pass it in by pointer/reference. Of course if you modify the struct in the function it modifies the original.
@@napalm5 heh.. that explanation is what I was searching for, thanks
THANK YOU! It surpises me how can a teacher introduce this concept without explaining it at university. This was a life saver
I didn't know what a pointer is but this video is so clear it makes perfect sense. I've watched hundreds of videos over the months and yours are some of THE best. Well done, and much appreciated.
i have found that sometimes when i am really, *really* struggling to understand a concept it might simply be a product of obsessively trying to understand it, so your looking at like 50 interpretations of what a function is and bombarding your brain with too much information for the actual concept to have any cohesion. i remember reading that the best way to remember something is, well, i am going to inject the first part 1. apply what you learn to something you care about 2. repeat it [use it] 10 times in a row
thank you so much professor, you taught me something in 8 mins!
Happy to help!
@@LowLevelLearning hi
I am seeing your videos from a week I noticed that your explanation made all our ways clear in doubts but I have a question in this pointers topic on embedded c ?
The question was why pointers don't use in embedded c
Can you pls clarify the following questions with your explanation I had this doubt after watching this pointers topic in your channel...
@@ramakrishna4092 Rama, here's an answer to the common question "why we have to use pointers in embedded C". If you use the Pico/RP2040 SDK, you have to use pointers, the functions in the SDK demand that, and I think it'd be almost impossible to code for RP2040 in C/c++ without the SDK. As LLL says at 6:44, I figure the RPi programmers used pointers to get around scoping issues. They had to do it this way, so we do as well.
You think you understand pointers now? Then make sense of this type: int (*(*f())[13])()
@@mircopaul5259 wtf is that, lisp?
NASA said don't use pointers
?
Excellent! I looked at a couple of other tutorials, but only this one helped me. Thanks!
This has to be one of the best channels on youtube. I have been fighting this for so god dam long
If you have an array of structs, a pointer would be like passing the number inside the brackets, like array[0] or array[3] etc. As C pre complies everything in to tetris blocks repeated at a fixed interval, as each struck inside the array are 12bytes in size (example), so now you can refer to struct members with and offset of 0 to 11, you just pass base number to the functions, an absolute address in memory that is the base number to each "apartment block" and that is called a pointer.
I found pointers inheretly easy to understand when i was learning them, what can be hard, for me at least, is how to implement them in an effective way. I can understand the difficulty, since it involves computer memory.
Single most useful video i have seen all year! Thank you so much for this
this video was recommended to me at a perfect time, working on a final project and I'm mad confused about pointers. Thank you
I already understand pointers fully, but your explanation is so good / mesmerizing that I watch anyway. Great video.
Awesome, thank you!
Thanks for the video. I learned the basics of programming from PLT Scheme and became proficient from Python. I've been trying to learn C and I have a decent understanding of the concepts of pointers and addresses, but was struggling to understand why we need to pass pointers to functions instead of the object itself since that's something Python handles for you in the background. I want to take advantage of the power and speed of C, though, so this is very helpful.
Awesome I’m happy that it helped!
using a double pointer to create two dimensional structures(rows, cols) has been one of my favorite things to learn in college so far, and it goes deeper when you figure out you can create other pointers to increase the size it gets crazy
Every video about pointers I have seen so far has given an explanation of pointers which is exactly the definition of variables.
I come from the field of PLC programming. Until recently you could only program most PLCs with either a graphical programming language (good for logic tasks) or in assembler of the PLCs processor. (Good for data tasks).
Pointers were really to only way to implement a loop with a pointer iterating over a given field of data.
The good thing is pointers and memory handling are really easy in PLCs compared to PCs, so learning pointers there was a good start.
I learned to program PLCs in tech school about 3 years ago. I tell you this RN, my instructor would've thrown me out on my ear if he ever saw a pointer in my code. He nearly did so when I found the JMP command all on my own, especially after I (mis)used it and created an infinite loop. Apparently, not even he used the JMP instruction regularly in some 15 years of PLC coding, so he was in no position or mood to look at my code, see that there was a JMP going up the ladder instead of down, and correct it before problems arose.
getting LabView vibes
@@mage3690 Haha lmao
5:13 You can also say that if there was no asterisk, you would put the value of the pointer pX, which is a memory address, to the variable Y. You want the value of that memory address, so you put the asterisk there.
> _"if there was no asterisk, you would put the value of the pointer pX, which is a memory address, to the variable Y"_
which would cause issues
@@yash1152 why?
@@proloycodes i dont remember the specifics, try compiling with the compiler flags _-Werror -Wall -Wextra_ and see, it will tell you.
Wtf man this is way easier than I thought, I was having such a hard time to understand pointers. Love you ❤
such a underrated channel holy shid ive never found someone who can explain this good and easy
Finally, I get it!
Thanks
I learned pointers by starting out with JS, then learning about how computers work on the low level, then learning cpp, and trying out pointers. By then it was relatively intuitive lol
that may be because JavaScript doesn't have pointers
Watching this before my C++ exam, was stressing hard bc it’s all pointers. It’s so easy now! Thanks bubba
Seeing pointers in memory view is really helpful to visually see what's going on.
A small tip: Change the font you're using in your video. I know, might be weird to hear, but the ; symbole looks so weird, it makes the code look more complicated. I understood pointers years ago and when i saw your code, i was legit scared of it and thought, i forgot something important lol Or sometimes it looks like a " i " and i thought: Yo where is "xi" comming from
Same here, the semi-colon got me confused, needed to back it up a bit to confirm it was indeed just a semi-colon.
I think what caused the most confusion for me regarding pointers was when using * as the indicator that a variable was a pointer and using the same symbol to de-reference.... I think it would have caused much less confusion if we didn't use the asterisk for both
> _"* is both the pointer declaring and dereference operator.... much less confusion if we didn't use the asterisk for both
"_
yeah, i totally agree
Change the spacing and it makes more sense.
Func(int *pX)
{
int y = *pX;
}
@@protox4 no, it doesn't
(int *) - type of pointer, that points to integer number
* - dereference operator
they're absolutely two different things
@@dadoo6912 it's to do with the whole idea of "declaration follows use". The asterisk is on the variable name because in some weird way, it acts as the dereferencing operator within the declaration.
Something like `int *pX` really means (in terms of the declaration semantics) "`pX` is something that can be dereferenced (i.e. a pointer) and when you dereference it, you get an `int`."
Similarly, `double a[N]` reads "`a` is somthing that can be indexed (an array), where the maximum valid index is `N` (you can only access up to address `N-1`, mind), and when you do so, you get a double."
Another example: `void *pointers[5]`: "`pointers` can be indexed up to `5`, and doing so returns something that when dereferenced gives you `void` (you can't _actually_ dereference a void pointer at runtime, but if you _could,_ you'd supposedly get `void`)."
Also, `char (*array)[42]` reads "`array` can be dereferenced, which gives you something that can be indexed to give char (max index 42)."
Finally, `void (*print_function)(char *message)` means "`print_function` is something that can be dereferenced, yielding somthing that can be called (a function), which takes a single argument - given the optional name '`message`' - which can be dereferenced to give a char, and returns nothing (`void`)." Of course, function pointers don't actually need to be dereferenced to call the function they 'point' to, but the `*` differentiates between function pointers and ordinary function declarations.
Having said all that, I agree it's kind of weird, and could be avoided if C used different syntax for declaration (new languages probably should).
IT WORKED, THANKS I'VE BEEN LOOKING FOR THIS FOREVER, BUT NO TUTORIAL COULD EXPLAIN IT AS YOU DID
I was very fascinated by the pointers concept when I was studying it. When I studied its application in Linked List, I was so amazed to see its applications. The concept is just amazing.
Love this kind of explanation!
Glad it helped!
- int isn't necessarily 4 bytes, do not ever assume this, use int32_t if you want 4 bytes
- using p as a prefix is not a good habit. it originates from a misunderstanding how hungarian notation works. it doesn't add anything, we have had editors that can show you types for years and years now
- the age example misses the point that modifying a copy wouldn't do anything
- stuff that goes onto the stack is NOT static. it is automatic. static memory either uses the static keyword within a function or is defined outside a function. also an automatic allocation doesn't need to have a statically (at compile time) known size, VLAs do exist
To grasp that topic it is really helpful to generally know how the (at least abstracted) hardware of a computer works. I've been lucky enough that I've been raised in the 80s, so I learned on computers where you needed to know how it works internally to program them. That creates a visual idea of what variables and pointers are.
In C and C++ it can be even harder because you can even calculate with pointers. In other languages they exist for the same purposes explained in this (excellent) video but you can not calculate with them (Go e.g.). And languages like Java do have them only under the hood and you sometimes get an idea they exist internally when you hit something like a "NullPointerException".
Perhaps you want to create a follow up video explaining pointer arithmetics and how they look in other languages?
Thx for the good work!
Thank you for the clear and concise explanation!
I want to add, for people trying to understand why the * usage is different when by a type. It's not. The asterisk just isn't by the type, its by the name.
int * x;
is not saying x is an int pointer, its saying that dereferenced x is an int.
This helped me immensely when I realized it, and it explains:
int * x, y;
makes x a pointer and y an int since y isnt dereferenced but x is in the declaration.
One of the best explanations I have seen so far
Okay what what is THE best one you've seen ?
The only thing i missed was WHY you would use pointers. I have no clue and would love to learn. This sounds just like same variable has different name, sounds more confusing to use than anything else.
@@AndrewTSq why do we use street numbers? also, he explains it in the last part of the video. have you watched it? you cant just "pass variables to functions". either you pass the object itself by value, or you pass the address where it is stored in memory. what's difficult to grasp?
@@itellyouforfree7238 to see where we are? and if we are at the right address? Do you mean pointers are to get a variables memoryaddress? but why would you want to use that instead of just using the variable?
This video literally made me understand at all what pointers are tbh
I was having a lot of trouble with them
Thank u so much
I love it! Thank you for this explanation, it made everything clear for me
I think the biggest source of confusion is the syntax and why we need to specify the data type when declaring a pointer. Very often, I see people explaining pointers by emphasizing where the data begins (i.e. the address) but not where the data ends!
That's because pointers have very little care for where the data ends that on you to manage. at best a pointer will use its type to figure out the end of the first element but that feels more like syntactic sugar in C. it will quite happily ignore it if you even so much as implicit cast
I think the issue has always been squarely down to the way they are used in c. You cannot intuitively infer what a * or & means if they used terms like addressof instead people wouldn't get so confused. But its like that because only a few ascii symbols were available at the time and so that is the way that it is. If you start by programming a simple micro controller using assembly its gets hard quickly, you basically need a higher level language to take care of branching and addressing memory - when you come at it from that angle it makes 100% sense to the point where you almost invent the need yourself - only to find c has your back.
If you don't use c at least monthly you forget the syntax and thats when we get into the stabbing * or & in because we know its one of them of some form.
Efficient code uses pointers because its much faster to point or reference data than to keep moving it. The downside is that since an address is just a number you can very easily point to memory that isn't what you intended. Even the best programmers can easily get caught by an edge case - so there's a trade off between efficient and safe code - i.e. you can spend 20 instructions checking the bounds and 1 instruction copying data to be safe but thats inefficient, so it depends on what your doing.
By far the largest confusion for students are strings, char arrays, pointers to, const char arrays and when and which to use - discussion for another day.
Really good work bruh!!! Everything is explained slowly and step-by-step, word-by-word
pointers are easy to learn and even easier to forget.
i’m keeping this one on my fav videos for next c project
I've been programming on the 6809 chip where pointer indirection is built into the instruction set. To me it's clear and makes sense. However I get super confused as soon as I try to apply that understanding to C or C++.
I've never found pointers to be all that difficult. This may well be the result of learning PDP-11 assembly with its register addressing modes before any high level languages that supported pointers.
To be fair, in assembly the ONLY way to read/write things in memory is using a pointer, you have little other choices. Assembly programmers should be fluent in using pointers.
@@SerBallister Assembly programmers also understand that types don't exist and pointers are literally just integers, which is imo what makes the most difference.
I don't remember them being that difficult, either. But I have been writing software for quite some time, now. It's possible they were, when I was learning. What concerns me is that people now seem to want to write code without actually understanding what the machine does with it. That's how you wind up with buggy, vulnerable, bloated and slow software. Of which there is a great deal.
Yeah, I came from 6510 and ARM assembly and never had a single problem with them. Didn't even know the terminology, just used them.
@@fghsgh That comes with a down sides though, people make false assumptions about the languages. In C/C++ pointers aren't just integers and types are very real, to the point where you very easily invoke undefined behavior. People think of C/C++ in terms of assembly when the two have nothing in common, they target an abstract machine, not your hardware.
Before I did week 5 of CS50 I had the impression that complex data structures just need arrays/lists and that’s it. But now I realise how bloody amazing these things really are. The fact you can link multiple things together all using pointers was such an eye opener when it comes to programming.
This is the better video programming content I have never seen, simply insane good.
A word of caution. You may be tempted do void* or char* cast your pointers to get past some funky type casting foo, but be warned, if you wish to enable compiler optimisation, it will refuse to optimise code that's be obfuscated (to it) this way. It need to have concrete, validatable frame pointers for the variables. It's not stupid and will fail on a void* and in cases where it sees you casting a char* back to a somethingelse* it may fail too. I say "caution" as fixing this later in any size of code base will ruin you month.
Error: segmentation fault (core dumped)
I can see why my methodology instructor dedicated much of the lecture explaining those seemingly minor details about pointers and memory location with just a single line of code. Looking at this video, I remind myself of how straightforward the syntax of a pointer is.
The real challenge for many student learning pointers is forming and retaining a connection between these small chunks of information they already have to figure out what is happening throughout the program.
Wow that was sooo easy now i understand concepts of pointers thank you very much
While pointers as a concept is easy, I think it's rather the C and C++ syntax that creates most of the confusion. Even the 6502 has few addressing modes that use pointers, and they weren't that hard to understand when I was learning them.
What may be worse is that C++ reads RTL and C reads LTR. const char* x in C is a constant character pointer, const char* in C++ is a pointer to a character constant. Lol
The thing that always bugs me about pointers in C++ isn't complexity or their memory side effects, but the symbols, I know what everything does, but I always confuse the symbols because & has at least 3 different functions as a singular symbol depending on where you put it (bitwise AND, make a variable a type reference, or a get reference operation) as does * (multiply, make a variable a type pointer, or a dereference operation) and it makes reading the code for me a super pain in the ass. I'm totally comfortable with pointers, I just hate the syntax for them.
Dyslexia makes it worse trust me.
@@po1sonseede9001 Yeah I bet, other stupid thing that makes it doubly confusing in C++ is that neither of those symbols apply to the statement as a whole, only to the identifier, so instead of writing:
int* p_1, p_2, p_3;
you gotta write:
int *p_1, *p_2, *p_3;
even though an overwhelming majority of cases you will have multiple pointers being declared at the same time. Conventionally you would see int* as a type, but for some reason in C and thus C++ int is the type and the *p_1 defines a modification to the type exclusive to the identifier that isn't shared with any other object declaration in the language. Only contributing to C/C++'s anti-intuitive nature.
@@Spartan322 I think what bothers me is everyone wants a C/C++-Like syntax nowadays, completely disregarding if the syntax is intuitive.
@@po1sonseede9001 Yeah, everyone keeps trying to copy C/C++ in such a manner that makes it still a pain in the ass, I wouldn't mind new languages taking a lot of the clean parts of C++ and implementing them in a more readable fashion, but for some reason instead we get Rust and Zig where they try to retain a high amount of C comparisons but you need to declare the variable and then the type alongside all these other things that honestly just feel like a snub at C and C++. Like why are we going back to pre-ALGOL mathematical type specifications? In almost every case the type is necessary information and you still need a structure to a declaration of variables, its cleaner to integrate the type into the declaration then making it look like an addon to the declaration. Its even uglier for functions.
You just don't know C/C++... Dont lie to us and to yourself... 😅
amazing video, you delivered pointer concept with easy example. impressive
Appreciate this as I'm learning C in an apprenticeship now. Thanks!
Great video! Can you give a more advanced tutorial, like using pointers with arrays and functions?
You mentioned double pointers and array pointers but didn't dive into them at all. You should make a part 2 on that.
Thank you for the very well paced and clearly explained video.
Pointers made easy by lll! Loved the video and suddenly everything became a lot clearer! Ty :)
Personally, I didn't have much trouble understanding the concept of pointers and how to use them in C, but a lot of people get thrown off by the fact that the * doubles (pun not intended) as both a type-specifier for a pointer (in an expression like int* or char*) and the dereference operator (in an expression like *p += 1)
Copying from another one of my replies,
That's the beauty of it, try formatting your code like
int *foo;
This basically means foo is a pointer, and you can access the value with *. It also reduces confusion with
int *foo, bar;
Here bar is an int, foo is an int pointer. This would be a lot more confusing if I wrote it as
int* foo, bar;
which'd make it seem like int pointer is a type, and foo/bar are instances.
@@casualoutlaw540 Yeah that's a useful formatting tip about keeping the *s with the names.
6:49 "malloc failed bruh" 🤣
I have been using pointers for a whole ass year now in a VR Company and I never understood them fully (just the basics) it just worked. I had to mix some of the options to see if it gave an error. Lol thanks
Finally, I understand pointers. Thanks for the video!
Great video! Not sure if it's just me, but I would suggest to change font for some of the examples as the ; looks too much like an i
Thanks for the tip!
@@LowLevelLearning Song name, pls?
I only learned about pointers when I learnt my second language, Rust. I never actually had problems with pointers that much (or Rust really just calls them references, when you say pointer in Rust you are normally referring to a raw pointer.) The syntax is just so easy to understand! And it automatically dereferences for you
References also exist in C++ and are not the same as pointers.
There's the auto dereferencing you mentioned and also you can't reference another reference, while you can have a pointer to another pointer.
@@waynezor in rust references reference other references all you want... although you don't normally have much reason to.
To me references have always just been raw pointers but they have guarantees about mutable aliasing (and auto deref). Casting a reference to a raw pointer in rust is a NOP I believe.
Does C++ have the same no mutable aliasing guarantees?
@@VixieTSQ Let me know if i'm wrong but in Rust you can't have two pointers to the same address because of the one owner rule, when you points to another variable address then the original variable loses the context and dies.
@@sudovon6531 pointing != ownership. With rust references you can either have multiple immutable reference or one mutable reference to one value.
But pointers in rust are diferent and not commonly used. They require an unsafe block to dereference because you can do whatever you want with them. You can delete all the pointers and let the value leak. You can delete the value and dereference a null value. It's scary stuff.
Thank you very much for clearing the concept ❤
Simple and easy to understand. I wish this had existed 25-ish years ago when I first learned about pointers. Would have made it so much easier to understand. I'm glad I stuck with it though, because now it's fun to write functions to do single allocations for 2d and 3d pointers and set it up for the user of that function. Well, if anyone actually uses it, but it was fun writing and debugging anyhow.
For the algorithm. Excellent channel btw!
Welcome aboard!
u know arrays, right? well, all of memory is an array. a pointer is an index of this array. yup, thats it.
Thank you bro, you really saved my desire to continue learning C++
I haven't started the C language yet but understood pointers... thanks 👍
damn i didnt understand a thing you said... so glad i work with a language without pointers
bruh
lol
I think the hardest part about pointers is just the syntax. Using the * to create a pointer variable and also using * to dereference the pointer to get the value is confusing
That's the beauty of it, try formatting your code like
int *foo;
This basically means foo is a pointer, and you can access the value with *. It also reduces confusion with
int *foo, bar;
Here bar is an int, foo is an int pointer. This would be a lot more confusing if I wrote it as
int* foo, bar;
which'd make it seem like int pointer is a type, and foo/bar are instances.
I think it's more confusing that * is both used for multiplication and pointers. & Is used for bitwise operations and creating a reference.
Why not use different symbols?
need more video like this format
I really love you man! You teach so good
3:45 It isn't always modifying the type!
`int* x, y;` doesn't mean that you would create two `int` pointers, `int *x, *y;` does!
Casting to an `int*`, however will work as expected.
I still suck at pointers in general but taking a course in Assembly really helped me understand pointers and memory.
Great video as always! I think a dedicated video that demonstrates several cases when / why a pointer is /should be used would be great. I know it was touched on in the end of this one, but a extended one would be greatly appreciated!