Thread: Pointers/references

From the code generated perspective: Not a lot [except when the compiler can completely remove a reference and just access the original variable, whilst a pointer would have to go through the pointer at all times]. From the usage perspective, quite a bit. Aside from syntactical differences, references can not be changed after the first assignment (so you can't change WHICH OBJECT a reference refers to), and references are always pointing to a valid object [unless you do really weird undefined stuff].

--
Mats

Most compilers (AFAIK) implement references in terms of pointers.
The standard says a reference may take no memory at all, however.
The conclusion is: it's implementation-defined. You'll have to look at the assembly output of your compiler to know.

Originally Posted by RobotGymnast

oh, okay, thanks.. but how does something take no memory? does that mean it's only different in the compiler, and once compiled, a reference IS the thing it's a reference to?

Well generally, that's what a reference means -- it IS the object being referred to. That's how people usually think of them. Whether the compiler inlines it or uses a pointer under the covers depends on a lot of factors and is usually irrelevant to most people.

A reference probably might only exist at code level (but then a pointer in some cases might too?).

For example, if you have

Code:

int i = 5;
int& ri = i
ri += 5;

the compiler might simply translate it to:

Code:

int i = 5;
i += 5;

and there would be nothing corresponding to the reference.

This might work for a pointer too, but if I'm not mistaken, it can be harder for the compiler to prove that the pointer is still pointing to the same thing (a reference has to refer to the same thing).

--------
Whether you pass things via references or pointers varies among people (although there are some cases where you must use references - e.g operator overloading, copy constructor). Personally I use pointers only where I need the ability to pass NULL, or to change the pointer (e.g pointers to arrays).

Others prefer to use pointers when the function is intended to modify what is pointed to, as taking the address at the place of call would indicate that.

Code:

void foo(int* n)
{
    *n = 42;
}

int main()
{
    int m;
    foo(&m); //clear that something's going on here: m can be modified

    //but
    int* p = &m;
    foo(p); //doesn't stand out particularly?
}

Originally Posted by anon

Others prefer to use pointers when the function is intended to modify what is pointed to, as taking the address at the place of call would indicate that.

I don't buy that, though.
If the function isn't going to modify what it takes, it takes a const reference, and otherwise not.
Nevertheless, the "C++" way is typically to use references wherever possible.

Originally Posted by Elysia

I don't buy that, though.
If the function isn't going to modify what it takes, it takes a const reference, and otherwise not.
Nevertheless, the "C++" way is typically to use references wherever possible.

Maybe this is just proof that I'm not a C++ programmer to the soul (or is that sole?), but a little while back, I chased a bug where a member-variable was passed to another object, and later on it had changed. That was, because the other object stored a reference to the original variable. That is the kind of "hidden" thing, whilst if it had taken a pointer, I had known IMMEDIATELY that it was potentially modifying the value later on.

--
Mats

Originally Posted by anon

A reference probably might only exist at code level (but then a pointer in some cases might too?).

For example, if you have

Code:

int i = 5;
int& ri = i
ri += 5;

the compiler might simply translate it to:

Code:

int i = 5;
i += 5;

and there would be nothing corresponding to the reference.

Yes, and you can make that more complex:

Code:

int &ri = somestruct.a.b.i;

could still be done without actually storing the location of the final member i anywhere, since there is little or no benefit [assuming the number of times ri is used is relatively small] to have the extra overhead of storing the location of the final member i vs. using the location directly.

--
Mats

I use references when passing variables to functions, but never to store them (too inflexible for that).