Printable View
I must admit that the nuance between these two escapes me.
I understand the syntactical differences between using the two, but I do not understand how and when one is more useful than the other.
Can someone please either explain or point me to a good explanation on this subject? I.e. specifically one contrasting pointers and references, not just separate documentation for pointers and references.
Thanks!
You can think of a reference as basically the same thing as a const pointer, except that it 'implicitly' dereferences itself when you try to write to it or read from it.
That is, you never have to worry about using dereference or address-of operators with references, so functions can take parameters by reference, and also return by reference, and do it 'behind the scenes'.
References are usually easier to use for this reason, and because they always point to valid memory and cannot be rebound to another location, they're much safer than pointers.
You never have to check a reference for null. That is a big difference. Going the other way, you can't assign null to a reference, so you can't use it for an optional parameter.
Well, you can assign null to a reference whose type is 'const [typeof(NULL)]&', which would essentially create an alias for NULL. But yes, a reference is guaranteed to refer to a valid object, and it is implicitly const and therefore cannot be rebound like pointers.Quote:
Originally Posted by Daved
What the holy hell is that???Quote:
Originally Posted by rudyman
My compiler says that typeof NULL is const int, so it would be valid to say 'const int& null_ref = NULL;', although that isn't portable code, yet.
NULL in C++ is defined as 0.
const int& null_ref = NULL is valid and portable, but it will create a temporary int to hold 0.
And why would one want to do that anyways...
You can think of a pointer as a variable holding a memory address, and a reference as an alias name for an object. The implementation of the two may be the same, but the implementation is irrelevant when it comes to thinking about them.
Thus, a pointer is used when you deal with memory - dynamically allocated objects (new and delete) and iteration over an array come to mind.
You use a reference when you deal with aliases, mostly in parameter passing if you don't want to copy the argument.
That is in actual fact, uncompileable rubbish.Quote:
Originally Posted by rudyman
There is no such thing as a null-reference, the standard says so!
Things with references that differ from pointers:
- A reference cannot be null
- A reference must be assigned upon creation
- A reference cannot be changed to refer to something else
- A const reference is the only thing that can extend the lifetime of a temporary object
Actually, it is not the same as a "null reference". It is merely a const reference to an int that is bound to an integer literal. Since const references may be bound to rvalues, this is legal (and thus compilable), as Elysia has pointed out. It is still rubbish in the sense that NULL is intended as a null pointer constant, so initialising an int reference with it is not semantically correct.Quote:
That is in actual fact, uncompileable rubbish.
There is no such thing as a null-reference, the standard says so!
It just doesn't mean what rudyman thinks it means.
But you can emulate a reference!
Thus it's possible to create a "null reference" :p
Well, bad idea anyway. Most will disagree with such approaches.
If null is defined as 0, and you can create a reference to 0, then you can create a reference to null. I somehow managed to say that in the most poorly worded way possible, but I was just pointing out that although technically there's no reason or use for it, it is possible to assign and check a reference to be null.Quote:
Originally Posted by CornedBee
I think that your wording is fine, but you should have clarified Daved's wording outright instead of trying to be funny by taking it literally. Clearly, Daved meant that while there are null pointers, there are no null references since references always refer to objects (though due to a programming error they might "refer" to an object that no longer exists, but this would be in the realm of undefined behaviour, if I remember correctly).Quote:
If null is defined as 0, and you can create a reference to 0, then you can create a reference to null. I somehow managed to say that in the most poorly worded way possible, but I was just pointing out that although technically there's no reason or use for it, it is possible to assign and check a reference to be null.
Yes, this is possible:
But ref only refers to the value 0. It has a different meaning than a NULL pointer which signifies that it doesn't point to anything.Code:const int& ref = 0;
And anyway, you can only create your "null references" for integral types (or types where such implicit construction is possible) only.
While technically possible, it would rather assume that the object pointed to (referred to, referee), is rather 0 or does not have a reasonable value, but the reference itself is still valid, hence it isn't really a null reference.Quote:
Originally Posted by rudyman
It is technically possible to emulate a null reference via C++ classes, though, if you really want a null reference.
I think another nuance to understand, is that references are not objects, but pointers are. I don't mean objects in an OOP sense, but rather in a storage sense. When you use the name of the pointer, you are referring to the pointer's place in memory, not the thing pointed to. For that, obviously you need the '*' to get to it. References are just a different name for something, and that is all. They are not a region of storage in their own right.Quote:
Originally Posted by m37h0d
I guess you could say that pointers are more useful when you want to use a "place" in memory, but references are better when you want to use a "thing" in memory. I hope that nuance is a clearer nuance than the nuance between pointers and references. ;)
You are incorrect in that references do not take storage. They do.
I don't know what the standards say, but references are just a different way of using pointers. They work on the same concept, except with the syntax difference.
When you pass something by reference, the address is passed of that object, just like a pointer. You just don't "see" it or do it manually. It's done automatically for you.
Of course, references are NOT the same as pointers, but in the low level of things, they work the same [unless the standard states otherwise; I don't know what it says on this.]
Conceptually true, though technically "it is unspecified whether or not a reference requires storage" (Paragraph 3, Section 8.3.2, 2003 edition of the C++ Standard).Quote:
I think another nuance to understand, is that references are not objects, but pointers are. I don't mean objects in an OOP sense, but rather in a storage sense. When you use the name of the pointer, you are referring to the pointer's place in memory, not the thing pointed to. For that, obviously you need the '*' to get to it. References are just a different name for something, and that is all. They are not a region of storage in their own right.
Generally, pointers are used for three prinicples.
Arranging and allocating data on the heap
Passing an argument to a function via reference
Passing an object to a function
Two of the above can be done via references, but obviously as many have pointed out, all memory is done via pointers ( new/delete).
Pointers do have other uses of course, such as Nodes and link lists.
I would like to point out that saying "by reference" is bad, since it's a (IMO) C++-only term and refers to references and not pointers, so the correct term should be passing an argument to a function via pointer.Quote:
Originally Posted by swgh
It's not. "Passing by reference" was used in C to describe passing a pointer before C++ even existed.Quote:
since it's a (IMO) C++-only term
I know it is, but I'm saying that expressing it that way is wrong and misleading. I urge the usage of pass by pointer instead to reduce confusion.
swgh was pointing out that pointers can be used to implement (programming language-agnostic) pass-by-reference, as one learns about it in proper programming courses.
It wouldn't make sense to say that pointers can be used to implement pass-by-pointer. That statement contains zero information.
Good point. Thanks for the clarification. I was primarily talking from a conceptual point of view, but I didn't make that explicit.Quote:
Originally Posted by laserlight
Well, it didn't sound like that in the post.Quote:
Originally Posted by CornedBee
But you are correct in that it makes much more sense in saying pointers can be used to implement pass-by-reference.
The jury agrees!
I was speaking conceptually about the differences between pointers and references, which I did not make explicitly clear in my post. Conceptually, references are not objects and do not require storage. Pointers are and do.Quote:
Originally Posted by Elysia
Oh, I may have quoted the wrong post back there.Quote:
Originally Posted by laserlight
Sounds like you're not getting this, though I'm sure you kinda are; You cannot check a reference for null because it cannot be null.Quote:
Originally Posted by rudyman