In short: Pointers and references can be used to refer to data in memory, without copying the data to a new variable. That is efficient. While pointers can arbitrarily be changed to point to any memory addresses and need a dereferentiation in order to read the value, references do refer to a fixed location in memory and behave like normal variables (do not need dereferentiation), when one wants to read their value. However, since no data is copied from one var to another in either case, changes made to these memory locations will be present instantly for pointers and references.
What’s the reason for the language to have references at all? Why not just pointers? It doesn’t seem like references can do anything we couldn’t already do with pointers.
@@Singularitarian I'm relatively new to C++ and pointers / references so my answer could be wrong but I had the same question after watching the video initially. However, upon further thought, I don't think that references are used in the way that the video demonstrated. I think the main use case is to use a reference value as the formal parameter of a function so that when you're passing large values to a function, you aren't compromising performance by copying the entire value; hence the terms 'pass by value' vs. 'pass by reference'. That being said, I could also be completely wrong so if anyone sees this and can clarify for us, that would be greatly appreciated. Cheers!
@@Singularitarian I think sometimes you have to "decode" a variable and pointers may not have to go through that to work in an equation. It might make a cheap way to have a "global variable" by making a ref to it. It's probably a read only type situation. I'm not sure lol that's why I watched this video....
@@AxeMask Pointers are not in every programming language. Take PHP as an example, they only work with references. The key differences with an example: A pointer is a variable, that points to the address of another variable, but it CAN be changed, CAN be NULL AND you can dereference it, so you can access the memory itself or the address to it. A reference is a variable, that points to the address of another variable, but it CANT be changed and CANT be NULL. Lets say you have a function which always expect a User object. Than you dont want a pointer. A pointer could be NULL, so your function cant work and there will be errors if it is NULL. You could check before, if its not NULL, but this costs additional ressources. Also someone could change the value where the pointer is pointing too within their memory. This can be unexpected behavior. Better would be a reference in that case. You can be sure with references, that they have a valid value of the specific type (in this example a User object). Also for some styleguide if there is a &foo parameter in your function(if not const), you can assume it will probably get changed. Lets say you have an array with object. (Dont mind me if the syntax is not completly right, havent used C++ in a while, i try to make it at least somehow clear what i try to do and fk styleguides on yt) public function getTheHighestNumber(&numbers) { *highestNumber = numbers[0]; //Get first number of numbers array count = size(numbers); for(i = 1; i
1 small thing you didnt mention is that pointers also have their own memory address. Just like any variable calling operator & on a pointer returns the address of the pointer, which is different to the value of the pointer, being a memory address that it is pointing to
Definitely the best video on RUclips explaining the difference between pointers and references. Also, thank you for not using all the programming jargon when explaining. Thank you!
Great explanation. Simple and concise. I've been taking a Lynda course C++ Essential Training by Bill Weinman but he blows through the explanation leaving me in the dust. I could see the results of what was happening in his code example, but it lacked the graphical elements that would help me understand. You did that, and it is now clear. Thanks.
At last, after years, I finally understand how pointers and references works. 🤯 Thank you very much for the explanation with visualizing the code itself! 😁👍
bro, you made this so easy to understand. you're such a genius, I cant wait to come back to this channel for more things like this when I need it. keep it up
i really appreciate writing the code while explaining the concept. I struggle understanding this concept with just drawings alone and then carrying it over to my projects. thank you
The diagram gives the impression that ptr holds a meaningful value after int* ptr; It does not. It holds garbage. It does not get assigned any value. It will just contain whatever garbage is in memory the moment ptr gets created.. Also references are under the hood pointers that behave like value types. But they are not value types. Once the original value object they are referring to goes out of scope, the refernce now is dangling (invalid). You have to make sure, that your original value object outlives the lifetime of the reference.
Slight correction, pointers and references are really the same thing only differing slightly with syntax. You could liken a reference to a pointer that is never null and can only be set once (when declared). There are surely some syntax differences when working with pointers (no need to dereference, dot operator instead of arrow, etc), but they are really doing the same thing otherwise. You can verify by messing around with godbolt (looking at disassembly). Also note that you can do polymorphism with references. Thanks for the C++ content! The world needs more C++ enthusiasts! :)
I'm just nitpicking here, but it's impossible to have two ints on addresses 0xA and 0xB, because int is usually 4 bytes, so the integer on address 0xA actually lives on 0xB, 0xC and 0xD too. I know it doesn't make a lotta difference, but I think it's good to know
A could be 0x66294701 and B could be 0x55399572 In other words, A and B are names, and B != A + 1 That's why he used uppercases instead of writing 0x0000000a and 0x0000000b
it's also impossible to have 4 bits (single hex digit) memory address on any usable computer. So your knit picking missed the point that these just mean arbitrary addresses A and B.
Pointers have their own intrinsic address (memory address of the variable or object in question), while references do not. The intrinsic direction of the pointer is different from that of the variable or object it points to. Instead, the intrinsic direction of the reference is the same as the variable or object to which it was associated. The reference is simply an alias for the variable or object to which it is associated. As a complement, you can think of a reference as another name that is given to the variable or object to which said reference is associated. That is, the variable or object whose memory address is associated with the reference will no longer have a way of being called but 2. In other words, the variable or object that is assigned to the reference can be called with two different names, either with the name of the reference or with the name of the variable or object that is assigned to the reference.
Hello, very good explanation! Can you cover in your next videos more advanced topics such as *&, **&. I know it is a combination of pointers and references, but extra explanation and exercises always help! Thank you!
Great lecture but what I find a little tricky is that initially when we introduced the ref we used & ref = var , now if we want the pointer to point to var we write ptr = &var and if we want the pointer to point to ref which is var we write ptr = &ref .In a mathematical sense people can get confused here because initially & ref = var and (ptr = &var or ptr = &ref but &ref = var so in this sense it becomes like var = &var).
you can not declare a reference without assignment, so it has to be assigned during the declaration not like a pointer which can be declared as an empty pointer then point to specific variable/object, point can be casting to a different data type but reference is fixed for that data type only, so a reference can be seen as an alias to the variable.
The ptr has a location and address as well. You should point out that, and that by default the address to the vars would be sequential with offset of the previous ones size. Also as ptr points to zero it would *ptr actually show the value of whatever is at zero location. If these are statically defined then yes it would be preinit to zero but if it was on the stack it might not be zero.
Hey nice video. It could have been nice to explore in more detail the difference using references vs pointers as arguments with functions, inside classes, with more complex objects, etc... But thanks for the video anyway!
Integer pointers take two or more memory location however have the memory locations 0xA and 0xB one byte appart. memory size of the pointer is hardware specific and compiler specific and the memory locations should be 0xA and at minimum 0xC (2 bytes) or some 32bit compilers have integer sizes 4 bytes ie 0xA and then 0xE
a reference is a pointer with more strict rules. it holds the address of other things in memory but it cannot be retargeted and must be initialized when created. this means you have less control but is safer since you cant accidentally point to bad memory locations. i usually use c so i am used to pointers but its just an option in c++
Not strictly true, you *can* accidentally bind your reference to a bad address by dereferencing an invalid pointer. It rarely happens, but does happen in practice with careless memory management and various mishmashes of semantics. I made a little test with g++ and this doesn't segfault till we try to read the reference which is effectively null: int* test_ptr = nullptr; int& test_ref = *test_ptr; printf("bound a nil reference "); printf("value of testref: %i ", test_ref); // segfault another way references are odd is that they apply value semantics to your pointer - so for example test_ref = some_other_variable; is assigning the variable that test_ref actually points to with the value of some_other_variable - and not making test_ref a reference to some_other_variable.and also C++ has operator overloading so if you have a class with an overloaded operator= then c++ will actually invoke that on your second usage of the equals operator with your reference variable. I actually prefer the explicitness pointers give nowadays because it hides less of whats actually happening.
I commend people who want to learn this, because they're the ones who create managed languages which does all (or most) of this for us in the background.
In the last part about the reference. Does this mean that when we change the value of var, the value of ref also changes because it is pointing to the same address?
Pointer variable and reference variable in c++ both stores address of the allocated data in memory. In other words, they both points or reference to a data. They only differ in usage. Reference variables are immutable, you cannot point it to another block of data in memory once assigned. When you try to access the value of a reference variable it implicitly dereferences to the value it is pointing to. Thats why they are called 'alias'. On the other hand, pointers can point to different allocations in memory even if you already assigned it. Also pointers can be null at the moment if the data you intend to point is allocated in the future. Also you need to explicitly dereference a pointer to access the value.
In short: Pointers and references can be used to refer to data in memory, without copying the data to a new variable. That is efficient. While pointers can arbitrarily be changed to point to any memory addresses and need a dereferentiation in order to read the value, references do refer to a fixed location in memory and behave like normal variables (do not need dereferentiation), when one wants to read their value. However, since no data is copied from one var to another in either case, changes made to these memory locations will be present instantly for pointers and references.
Nice explanation, but next time could you drag that out into a 3 hour video? I get paid by the hour. Thanks.
What’s the reason for the language to have references at all? Why not just pointers? It doesn’t seem like references can do anything we couldn’t already do with pointers.
@@Singularitarian I'm relatively new to C++ and pointers / references so my answer could be wrong but I had the same question after watching the video initially. However, upon further thought, I don't think that references are used in the way that the video demonstrated. I think the main use case is to use a reference value as the formal parameter of a function so that when you're passing large values to a function, you aren't compromising performance by copying the entire value; hence the terms 'pass by value' vs. 'pass by reference'.
That being said, I could also be completely wrong so if anyone sees this and can clarify for us, that would be greatly appreciated. Cheers!
@@Singularitarian I think sometimes you have to "decode" a variable and pointers may not have to go through that to work in an equation. It might make a cheap way to have a "global variable" by making a ref to it. It's probably a read only type situation. I'm not sure lol that's why I watched this video....
@@AxeMask Pointers are not in every programming language. Take PHP as an example, they only work with references.
The key differences with an example:
A pointer is a variable, that points to the address of another variable, but it CAN be changed, CAN be NULL AND you can dereference it, so you can access the memory itself or the address to it.
A reference is a variable, that points to the address of another variable, but it CANT be changed and CANT be NULL.
Lets say you have a function which always expect a User object. Than you dont want a pointer. A pointer could be NULL, so your function cant work and there will be errors if it is NULL. You could check before, if its not NULL, but this costs additional ressources. Also someone could change the value where the pointer is pointing too within their memory. This can be unexpected behavior.
Better would be a reference in that case. You can be sure with references, that they have a valid value of the specific type (in this example a User object).
Also for some styleguide if there is a &foo parameter in your function(if not const), you can assume it will probably get changed.
Lets say you have an array with object. (Dont mind me if the syntax is not completly right, havent used C++ in a while, i try to make it at least somehow clear what i try to do and fk styleguides on yt)
public function getTheHighestNumber(&numbers)
{
*highestNumber = numbers[0]; //Get first number of numbers array
count = size(numbers);
for(i = 1; i
Liked the idea of split screen.... helps visualising the code.... awesome concept....
@Sara Kiba 😂😂
I can't understate how easy and simple you made this to understand, very epic.
These nerds try to act like they have an IQ of 300 by explaining things in a difficult way.
Totally agree!
It's been four year by now but still it is precious. This video make my day.
Literally the best explanation of the pointers in all of coding history.
I can't believe a seven-minute video summed up a concept that I did not understand for the longest time. Thank you so much for this.
1 small thing you didnt mention is that pointers also have their own memory address. Just like any variable calling operator & on a pointer returns the address of the pointer, which is different to the value of the pointer, being a memory address that it is pointing to
Definitely the best video on RUclips explaining the difference between pointers and references. Also, thank you for not using all the programming jargon when explaining. Thank you!
I know this is 3 years later but, this is the best most understandable pointer video ive ever seen ! Thank you for making it!
Great explanation. Simple and concise.
I've been taking a Lynda course C++ Essential Training by Bill Weinman but he blows through the explanation leaving me in the dust. I could see the results of what was happening in his code example, but it lacked the graphical elements that would help me understand. You did that, and it is now clear. Thanks.
Most flawless explination I've ever seen of any programming concept. Well done and thank you.
At last, after years, I finally understand how pointers and references works. 🤯
Thank you very much for the explanation with visualizing the code itself! 😁👍
7:21 - The main essence of the video. However, I would recommend everyone to watch the entire video from start till end without skipping.
bro so easy and simple explanation, I got a friend who has 35 years in programming and he didn't make it easy to understand. Thanks again brother
I'm amazed by how elegantly you explained this. Thank you for being such a great instructor!
THIS IS THE BEST VIDEO I'VE EVER SEEN FOR EXPLAINING POINTERS AND REFERENCES I CAN'T THANK YOU ENOUGH.
bro, you made this so easy to understand. you're such a genius, I cant wait to come back to this channel for more things like this when I need it. keep it up
This was the best explanation on both pointers and references I've found anywhere. Thank you!
Hands down the absolute best video on pointers I've even seen! I'm excited to watch your videos on LL and the rest of the different types of DS.
I suffered with pointers and references for close to a year, thanks a ton!
i really appreciate writing the code while explaining the concept. I struggle understanding this concept with just drawings alone and then carrying it over to my projects. thank you
The diagram gives the impression that ptr holds a meaningful value after int* ptr; It does not. It holds garbage. It does not get assigned any value. It will just contain whatever garbage is in memory the moment ptr gets created..
Also references are under the hood pointers that behave like value types. But they are not value types. Once the original value object they are referring to goes out of scope, the refernce now is dangling (invalid). You have to make sure, that your original value object outlives the lifetime of the reference.
Slight correction, pointers and references are really the same thing only differing slightly with syntax. You could liken a reference to a pointer that is never null and can only be set once (when declared). There are surely some syntax differences when working with pointers (no need to dereference, dot operator instead of arrow, etc), but they are really doing the same thing otherwise. You can verify by messing around with godbolt (looking at disassembly). Also note that you can do polymorphism with references.
Thanks for the C++ content! The world needs more C++ enthusiasts! :)
having c++ classes for 4 months, and i never had such a simple explanation between reference and pointers
I'm just nitpicking here, but it's impossible to have two ints on addresses 0xA and 0xB, because int is usually 4 bytes, so the integer on address 0xA actually lives on 0xB, 0xC and 0xD too. I know it doesn't make a lotta difference, but I think it's good to know
A could be 0x66294701 and B could be 0x55399572
In other words, A and B are names, and B != A + 1
That's why he used uppercases instead of writing 0x0000000a and 0x0000000b
it's also impossible to have 4 bits (single hex digit) memory address on any usable computer. So your knit picking missed the point that these just mean arbitrary addresses A and B.
love the visualization, conciseness, and easy to follow style of this video , thank you
Damn been looking for a good video on pointers for a while
I found it
Love how this was concise and diagrammatically explained.
by far the clearest video I've found.
basically a ref is an immutable pointer, i.e *int* * *const* ptr;
which automatically deferenced by the compiler when used, then nulled
never nulled
can you explain more cause i am lost
Pointers have their own intrinsic address (memory address of the variable or object in question), while references do not. The intrinsic direction of the pointer is different from that of the variable or object it points to. Instead, the intrinsic direction of the reference is the same as the variable or object to which it was associated. The reference is simply an alias for the variable or object to which it is associated.
As a complement, you can think of a reference as another name that is given to the variable or object to which said reference is associated. That is, the variable or object whose memory address is associated with the reference will no longer have a way of being called but 2. In other words, the variable or object that is assigned to the reference can be called with two different names, either with the name of the reference or with the name of the variable or object that is assigned to the reference.
Best video on the basics of pointers and reference. Period. :)
I like the idea of thinking about a reference as an always dereferenced pointer with constant value
My GF has a test tomorrow about this. You just helped me make it clearer for her. Thanks!
Wow! Can't express my gratitude in words! Thanks sir
the best explanation I've ever seen about pointers
Great explanation. Remember I struggled with this 20 years ago. Subbed.
Hello, very good explanation! Can you cover in your next videos more advanced topics such as *&, **&. I know it is a combination of pointers and references, but extra explanation and exercises always help! Thank you!
Honestly the best explanation of pointers I have ever seen. The diagram helped an unbelievable amount. I can't thank you enough.
This is by far the best explanation on this topic. Thanks a million Paul!
You are a life saviour ....man thank you so much....thank you so so so much !!!!!
beautifully explained.. i got goosebumps when i finally figured it out
This is the most excellent explanation video one can imagine
Great lecture but what I find a little tricky is that initially when we introduced the ref we used & ref = var , now if we want the pointer to point to var we write ptr = &var and if we want the pointer to point to ref which is var we write ptr = &ref .In a mathematical sense people can get confused here because initially & ref = var and (ptr = &var or ptr = &ref but &ref = var so in this sense it becomes like var = &var).
you can not declare a reference without assignment, so it has to be assigned during the declaration not like a pointer which can be declared as an empty pointer then point to specific variable/object, point can be casting to a different data type but reference is fixed for that data type only, so a reference can be seen as an alias to the variable.
The best video that explains pointers. Thank you
Happy to help!
You explained it waaaay better than my professor. I finally understood it thanks to your video!
You explained it so well i tried to understand the difference the whole day. Thank you🎉
Finally, someone just explains what an "alias" is.
Pointers and references in C++ are not easy to figure out, and your explanation makes things easier! Thanks :)
I DON'T KNOW YOU, BUT I LOVE YOU. Thanks a lot man! Visualising the code helped a lot!
Perfect explanation and the visualisation used really aided in my learning!
Man that's the best explanation I found online. Thanks a ton bro and kudos to your effort . All my doubts were cleared
The ptr has a location and address as well. You should point out that, and that by default the address to the vars would be sequential with offset of the previous ones size. Also as ptr points to zero it would *ptr actually show the value of whatever is at zero location. If these are statically defined then yes it would be preinit to zero but if it was on the stack it might not be zero.
Your explanation was better than my professor's!
Thank you for this tutorial! It was clear, concise, and easy to follow.
Suddenly! I feel that the pointer arithmetic is so easy😮
Thanks❤
Definitely less confusing now, thank you for the thorough explanation.
I enjoy the way you explained pointers, the chart helped a lot. Thanks!
short, simple, and helpful. Thanks!
te amo loco, viva el conocimiento libre y a disposicion de todxs!!!!
before i switched my career to art, i was always confused about this. thanks for the explanation; might come in handy some day.
i appreciate your explanation, way better than my university professor!
This was helpful. Always wondered what the difference was but never cared enough to Google it.
Hey nice video. It could have been nice to explore in more detail the difference using references vs pointers as arguments with functions, inside classes, with more complex objects, etc... But thanks for the video anyway!
Integer pointers take two or more memory location however have the memory locations 0xA and 0xB one byte appart. memory size of the pointer is hardware specific and compiler specific and the memory locations should be 0xA and at minimum 0xC (2 bytes) or some 32bit compilers have integer sizes 4 bytes ie 0xA and then 0xE
Yep, I also spotted this anomaly. Unless his machine has int8_t as int or Harvard architecture.
Paul your videos saves me every time 😭❤️ thanks a lot ❤️❤️❤️❤️❤️❤️
I loved how you explained this, so easy and clear. Thank you.
Absolutely amazing on the splitscreen teaching. Thank you so much.
And here I was thinking pointers would be hard to tackle, thank you so much for such an easy explanation .
Finally, someone explains this concept simply! :)
Excellent video. Excellent teacher. Thank You.
This visual approach helped me a lot!!!
Thankyou. it was a great explanation compared to other youtube videos. Thanks again.
His Tutorials are fantastic.
I don't know why he didn't continue uploading tutorials
Excellent explanation of the difference between a pointer and a reference.
Best video for pointers basic
a reference is a pointer with more strict rules. it holds the address of other things in memory but it cannot be retargeted and must be initialized when created. this means you have less control but is safer since you cant accidentally point to bad memory locations. i usually use c so i am used to pointers but its just an option in c++
Not strictly true, you *can* accidentally bind your reference to a bad address by dereferencing an invalid pointer. It rarely happens, but does happen in practice with careless memory management and various mishmashes of semantics. I made a little test with g++ and this doesn't segfault till we try to read the reference which is effectively null:
int* test_ptr = nullptr;
int& test_ref = *test_ptr;
printf("bound a nil reference
");
printf("value of testref: %i
", test_ref); // segfault
another way references are odd is that they apply value semantics to your pointer - so for example
test_ref = some_other_variable;
is assigning the variable that test_ref actually points to with the value of some_other_variable - and not making test_ref a reference to some_other_variable.and also C++ has operator overloading so if you have a class with an overloaded operator= then c++ will actually invoke that on your second usage of the equals operator with your reference variable.
I actually prefer the explicitness pointers give nowadays because it hides less of whats actually happening.
@@stevephillips2819 yeah i just meant as its intended use
Clear and concise. Just the way I love it.
Visuals helped tremendously. Thank you!
Very good explanation! easy to understand
I commend people who want to learn this, because they're the ones who create managed languages which does all (or most) of this for us in the background.
And that's why, pointers pose a security threat, whereas references don't.......
What a fantastic explanation - great work!
you're a great teacher
This was incredibly useful. Thank you for sharing!
Stuck it on 2x speed, great video.
Why *ptr has a good chance to be 0x0 without initialising it? In my opinion there is more chance *ptr is not 0x0 than 0x0.
bro , how simple is that Subject actually. Subscribed und liked. Thank u so much
In the last part about the reference. Does this mean that when we change the value of var, the value of ref also changes because it is pointing to the same address?
Thank you so much. Very well explained.
Liked the idea of split screen.... helps visualising the code
Dude thank you so much, so useful, so well explained you are the best
OMG, how easy to understand. thank you
Жаль что в универе эту тему не объясняли так доходчиво. Спасибо!
an example of the difference in functionality at the end would make this 💯🌊
Pointer variable and reference variable in c++ both stores address of the allocated data in memory. In other words, they both points or reference to a data. They only differ in usage. Reference variables are immutable, you cannot point it to another block of data in memory once assigned. When you try to access the value of a reference variable it implicitly dereferences to the value it is pointing to. Thats why they are called 'alias'. On the other hand, pointers can point to different allocations in memory even if you already assigned it. Also pointers can be null at the moment if the data you intend to point is allocated in the future. Also you need to explicitly dereference a pointer to access the value.
it was a hell question in my mind after you answered it thank you
Much appreciated, it's clear and concise, saved us a lot and time and hassle!
thanks for help man, short and sweet video
Finnaly, someone who explained reference =)