For reference, I shall now refer to pass by address as PSA
Let’s just get something out-of-the-way. Passing a parameter by address involves using pointers. Yes, those horrible little things that you hated/hate whilst you learnt/are learning C, C++.
The idea of pointers is hard to understand and the most common thing novices will say is “Why learn pointers?”
Well, this is one of those reasons to learn them. PBA relies completely on pointers and by using this, the performance of your application can improve massively, so yeah, this is why pointers are important.
So what makes by PBA different to pass by value? Well, as mentioned above, pass by value literally copies the parameter into the function. PBA, on the other hand, simply takes a pointer to a variable as a parameter and copies it into the function.
Therefore, any changes we make to the variable in the function (or, more specifically the pointer) are changes were really making to the original variable that the pointer points to. Confused? Quite possibly. To try to make some sense of this, take a gander at the code below:
[crayon-5ba4e88f05097726085243/] Have a go at predicting the output of this program first. Then go ahead and compile the program. You should get the following output:
What you predicted? Great you understand pointers! If not, let’s have a look at what happened.
We have two functions in this program (three if you count main()). The first one is called
passMe and takes a standard parameter of
(int x). This is a pass by value function and is pretty normal, this is probably what you’ve been doing in the past to pass an argument to a function.
Inside the function we set the variable x to = 42. Pretty simple. As you should know, that variable will remain limited to the scope of that function. The parameters value wont change.
Now have a look at the second function called passBy. This takes the argument of
(int *x). Notice the asterisk. This signifies that the parameter we pass will be the address to a variable, since the variable x is a pointer. Looking inside the function we find that we set the pointer x to 42. This means that the variable that we pass to x will change since all that pointer x does is point to that variable. This is pass by address. Lets see how we implemented that into the application.
Inside the main function, when we call the
passMe function, we pass a parameter of the variable through which is 10. This gives x the value of 10 too inside the passMe function. However, when we change the value of x. The value of through remains the same, as is shown later on in
main when we print the value of through which is still 10. With the
passByfunction however, we pass the argument
This means we pass the address of the variable by (which also equals 10). We therefore say that the pointer x (in the
passByfunction) points to the address of the variable by. Therefore, any changes we make to x, we are really making to the variable by hence why when we go on to print the variable by the value is 42.
Now this may seem somewhat pointless and on a small-scale like this it is. However, when we pass by address, we don’t copy any parameter to the function, so if we have a particularly large parameter, say a struct, passing the address of the struct isn’t going to cause an exponential increase in the memory usage of our application SO our application will run faster.
This isn’t the case in pass by value functions, as the entire parameter is copied to the function, increasing memory usage and slowing down our application substantially. That’s essentially the main advantage of using pass by address. The disadvantage of doing such a thing is obvious though.
We can change the value of a variable which, at first glance, appears to be outside of the scope of the function. Obviously this can have massive side effects so it’s really important that you only use pass by address when you really need to. At the same time though. Don’t be afraid to use it.