Printable View
What is the difference between these two alternatives? Are there performance tradeoffs? Any help appreciated. Examples below.
Code://Pass by pointer
void negate(int * pn)
{
*n=-*n;
}
void func()
{
int m=10;
negate(&m);//pass m's address<
std::cout<<m<<std::endl; //display: -10
}
//Pass by reference
void negate(int & n)
{
>n=-n;//modifies caller's argument
}
void func()
{
int m=10;
negate(m);//pass by reference
std::cout<<m<<std::endl; //diplay: -10
}
Both should work the same, in that the function can modify the value, their speed should also be the same due to compiler optimization.
A pointer can be NULL, a reference cannot.
Pointers sometimes have tricky precedence which a reference hides from you.
If I am passing a large vector structure that contains classes that I created, then which way of passing parameters would I use? I am guessing it doesn't matter. Would accessing elements of the vector be faster using one way as opposed to another?
It shouldn't be faster to access the vector one way or the other.
Normally I would pass by reference unless there is a reason to allow for a null value which is probably not the case here. Just make sure it is obvious that the function modifies the argument by using good function and variable names and comments.
> If I am passing a large vector structure that contains classes that I created
Why not try it, and put a trace statement in your copy constructor to see how much it gets hammered when you use pass by value.
Well I already know that pass by value isn't good except for when I am passing small variables around that I don't want the called function to change. I am only curious of the performance difference between pass by reference and pass by pointer (eg address).
> I am only curious of the performance difference between pass by reference and pass by pointer (eg address).
You mean like "none at all" ?
They both share the same underlying implementation as far as most compilers are concerned.
Another advantage of references over pointers is that references are type-safe.
>Why not try it, and put a trace statement in your copy constructor to see how much it gets hammered when you use pass by value.
Salem,
Is a trace statement just where you make it print out a variable basically? Never heard the term. (yes I am still a noob in MANY ways :D)
But references can only have one alias right? Meaning after they become referenced to another object they cannot be referenced to another object. I think pointers don't have this limitation. Let me know if I am totally wrong or only partially correct. Thanks
This is correct, but for a function parameter it doesn't really matter. Once you have passed an object to the function, you rarely need to change what the parameter refers to. In fact, this is generally an advantage of the reference in this case, since you don't have to worry about that. You can assume that it refers to a non-null object and that it won't change for the duration of the function.