Pointer arguments for functions [duplicate] - c++

Question

This question already has answers here:
What is a reference variable in C++?
(12 answers)
Closed 9 years ago.
One thing that I have not been able to understand is when to use certain types of pointers for arguments in functions.
Consider a function that receives an integer as its parameter, and doubles whatever that value may be. A function for that could be:
void doubleTheValue(int *myNum)
{
*myNum *= 2;
}
int main()
{
int number = 2;
doubleTheValue(&number);
// prints 4
cout << number << endl;
return 0;
}
This makes sense to me. The function receives an integer pointer, and you pass in a reference to the variable 'number' and it changes the value. Now, what confuses me is if you did this instead:
void doubleTheValue(int &myNum)
{
myNum *= 2;
}
int main()
{
int number = 2;
doubleTheValue(number);
// this also prints 4
cout << number << endl;
return 0;
}
Note the argument for the function is different. What exactly is this doing internally, and why would you use it over the aforementioned method?

Answer 1

What exactly is this doing internally, and why would you use it over the aforementioned method?
In your first example:
void doubleTheValue(int *myNum)
{
*myNum *= 2;
}
you are passing a pointer to the function. A pointer has an implementation defined size. For example, in 64bit architectures the size of a pointer might be 8 byte. In this case (and in general, for primitive types) it's counter productive to pass pointers instead of references (see next paragraph).
In your second example:
void doubleTheValue(int &myNum)
{
myNum *= 2;
}
you are passing a reference to the function. The main difference is that a reference is not even required to take any memory at all. myNum and the original variable could just share the same object in memory.
For other differences between references and pointers I suggest you to take a look at this question. But a general rule of thumb it to always use references when you can. You'll find the need of using pointers in specific situations (like, for example, when you want to accept a null-value).

Answer 2

What exactly is this doing internally, and why would you use it over the aforementioned method?
The & reference is to be read as an equivalence for the pointer reference parameter, but
... with guaranteed initialization
... without need to use a pointer dereference operator * to access the value/members inside the function implementation
To indicate error conditions for the passed parameter you'll need to use a return value type (not void), or throw an exception from inside your function. This generally applies to both variants.

Answer 3

You should understand the difference between a pointer and reference. In many cases we cannot do something using references which we can do using pointers. Although references do not need any memory and they are just tags to a memory location but in comparison with pointer, pointers are far more powerful than references.
The major differences are:
1- A pointer can be re-assigned any number of times while a reference can not be reassigned after initialization.
2-A pointer can point to NULL while reference can never point to NULL.
3-You can't take the address of a reference like you can with pointers
4-There's no "reference arithmetic" (but you can take the address of an object pointed by a reference and do pointer arithmetic on it as in &obj + 5)

Answer 4

From OP, in comments of original post:
Neither of this really give any use for applications nor explain why you would use one over the other which is what I am curious about.
My impression is that people mostly use references because they make the code look cleaner, so that there aren't a lot of * and & floating around.