C++ References - Why We Need Them

In the previous lessons, if we wanted a variable that could be updated from any function, we've stored that as a global variable.

This is because, based on what we've learned so far, a function cannot update a variable that is stored in another function.

To illustrate the issue we have, lets try this:

1#include <iostream>
2using namespace std;
3
4class Character {
5public:
6  int Health { 150 };
7}
8
9void Combat(Character Monster) {
10  Monster.Health -= 50;
11}
12
13int Main() {
14  Character Monster;
15  Combat(Monster);
16  cout << Monster.Health;
17}
18

Perhaps surprisingly, what this program logs out is 150 rather than the 100 we might expect.

We can simplify the problem even further:

1#include <iostream>
2using namespace std;
3
4void Increment(int Number) {
5  Number++;
6}
7
8int Main() {
9  int Number { 1 };
10  Increment(Number);
11  cout << Number;
12}
13

For similar reasons, this code will log out 1, not 2. It is perhaps more intuitive in this case why our code doesn't seem to be incrementing Number, especially given our earlier lesson on scopes.

The problem is that the Number inside our Increment function is not the same variable as the Number inside the main function. It is a copy of the variable that, at least initially, has the same value.

1void Increment(int Number) {
2  return Number + 1;
3}
4
5int x { Increment(1) };
6

1void Increment(int Number) {
2  Number++;
3}
4
5int x { 1 };
6Increment(x);
7

This behavior of how arguments are passed to functions is called pass-by-value. This means the arguments we pass in to functions have their value copied to a new variable. So, each variable has its own memory location. They have the same value at first, but are then updated independently By default, C++ passes arguments in this way.

So, we might now better understand what was happening with our more complex Monster object in the previous example. Specifically when we are passing our object to the Combat function:

1Character Monster;
2Combat(Monster);
3

The effect of the above code was that our monster object was copied when it was sent to the Combat function.

Anything that happened to our monster in the Combat function was happening to the copy. The monster in the main function was a different object.

Therefore, the health of the monster in our main function was still 150 - it was the health of the copy that was being reduced within the Combat function.

That copy effectively disappears when our Combat function completes.

Fortunately, pass-by-value is not the only option we have. The alternative method is pass-by-reference, and we will see how to do that in the next lesson!