Thread: Passing by refernce of address

One reason would be that the use of references simplifies the syntax (no need to take the address when passing and no need to dereference the pointer). Another reason would be that while a pointer parameter can be "optional" in the sense that a null pointer can be passed, a reference parameter would not be optional in that way.

I think you got confused here. There are only two types of passing parameters: Pass-by-refrence and Pass-by-value. Only pass-by-reference allows you to modify the original variable, whereas pass-by-value will modify only the local copy.
Maybe you have a more concrete example of what you're trying to achieve?

QuantumPete

In machine code they are both the same thing. When using references, you can be sure that the reference itself will be a valid memory address [unless you really jump through hoops to get there, or possibly that you are passing an argument like "*ptr"].

--
Mats

Originally Posted by QuantumPete

I think you got confused here. There are only two types of passing parameters: Pass-by-refrence and Pass-by-value. Only pass-by-reference allows you to modify the original variable, whereas pass-by-value will modify only the local copy.
Maybe you have a more concrete example of what you're trying to achieve?

QuantumPete

I took it to be the difference between C style pointer passing and C++ style references.

--
Mats

Passing by reference

• Doesn't require the address-of (&) operator when passing a variable
• Doesn't require the dereference (*) operator when changing the value of a reference
• Guarantees the argument will be an object (you can't have a NULL reference)
• Guarantees the reference will always refer to the same object

Pointers are mainly used for memory management, but here's an example to contrast pointers and references:

Code:

void f (int& ref)
{
   ref++; // Pretty
}

void f (int* ptr)
{
   (*ptr)++; // Ugly
}

int main()
{
   int var = 3;

   f (var); // Pass by reference, implicit
   f (&var); // Pass by pointer, explicit

   f (NULL); // Oops! Pass by pointer

   return 0;
}

EDIT: Posted a little too late

Originally Posted by cpjust

Even if you pass *ptr you can't have a NULL reference though, since it would crash as soon as you de-reference ptr; or were you thinking of a different situation?

I'm not sure, but if we do:

Code:

void foo(int &x)
{
    x++;
}

int main()
{
   int *px = 0;
   foo(*px);
}

I believe this will pass the address in px (0) to foo, and foo would crash. And you would have to do:

Code:

void foo(int &x)
{
   if (!&x)
      return; 
   x++;
}

to avoid that.

[I have just compiled the above (first version) code, and it does indeed crash inside the function foo when compiled with g++ mingw 3.4, whilst second version doesn't crash].

--
Mats

This dereferences a null pointer, so the behaviour is undefined even before it gets into the function.

Passing a reference signals that no checks are necessary (the wrong if at all has already been done). When a pointer is passed, it should probably always be checked for NULL, unless perhaps it is known to always come from a trusted source.

IMO, the thing is that undefined behaviour has already happened before that let you create a NULL reference in the first place, so the test would be too late. You won't test if an array index is out of bounds after you have accessed it.

On the language standard level, the UB occurs at the moment you do *ptr. At the machine code level of all implementations I know, however, "int& r = *ptr" is a simple copy of the address, so only using the reference will trigger the machine exception.

I agree with CornedBee - I was just trying to point out that a reference can lead to access to incorrect memory, and yes, the fault is in the calling code that doesn't check the pointer before making a reference of it. Unfortunately, that doesn't necessarily help in the debugging when you are several levels of complicated calls down from where the reference was set.

And no, I'm not suggesting that NULL checks are made to references - I just wanted to prove to myself that they can be checked. Checking for NULL on anything that isn't a pointer in the first place is meaningless - consider this:

Code:

struct A
{
   int x;
   int y;
};

A *pa = 0;

extern foo(int &x);   // Refers to the above foo with NULL check. 

int main()
{
    foo(pa->y);
...
}

Address 4 in memory will be the result of this, and it will crash just as much as address zero.

Out of bounds memory addresses can be achieved all sorts of different ways, and not only with NULL, so checking for NULL is not really helping - just let it crash if it's not right, and debug the exception. However, make sure that whenever possible, you check the range when indexing and return values from memory allocations!

--
Mats