C++ Function Arguments

We've seen how the execution of our functions can be controlled by conditional statements. These conditional statements allow our functions to potentially do different things each time they are called.

There is another way we can make our functions more flexible. We can pass some additional data to the function whenever we call it. These pieces of data are called the arguments of a function call.

Previously, we had a function like this:

1int Health { 100 };
2bool isDead { false };
3
4void TakeDamage() {
5  Health -= 50;
6  if (Health <= 100) isDead = true;
7}
8

This function was quite inflexible. Every time we called it, it did 50 damage.

1TakeDamage(); // 50 Damage
2TakeDamage(); // 50 Damage
3TakeDamage(); // 50 Damage
4

Instead, what we could do is pass some data into our function, letting the caller choose how much damage needs to be taken. That way, we could do a different amount of damage each time the function is called.

That value would be called an argument. We pass an argument between the ( and the ) that we've been using every time we called a function. For example:

1TakeDamage(20);
2TakeDamage(50);
3TakeDamage(2000);
4

To make this work, we also need to update our function to let it accept arguments, and to make use of them.

Updating a C++ Function to Accept Arguments

To allow our function to accept an argument, we add it to the parameter list between the ( and ) at the top of the function.

1int Health { 100 };
2bool isDead { false };
3
4void TakeDamage(int Damage) {
5  Health -= 50;
6  if (Health <= 100) isDead = true;
7}
8

A parameter (sometimes called "param") is a variable that is defined in the signature of the function. The signature is the combination of the function's name, the return type, and the type of all of it's parameters.

The signature is what we typically see on the first line of the function but, given C++ doesn't care about white space, the signature could span multiple lines.

In the above example, we define an integer parameter called Damage that, when the function is called, will be initialised to the value passed as the argument when calling the function.

Once we have set up our function to accept an argument, we can then update the body of the function to make use of that data where required. A parameter acts just the same as a variable within our function.

Instead of decreasing Health by 50, we can decrease it by whatever value is stored in the Damage parameter

1void TakeDamage(int Damage) {
2  Health -= Damage;
3  if (Health <= 100) isDead = true;
4}
5

Just like that, our code snippit will now work. Our function can now be called with a different Damage value each time.

1TakeDamage(20);
2TakeDamage(50);
3TakeDamage(2000);
4

1int Square(int x) {
2  return x * x;
3}
4
5int Result { Square(2) };
6

Multiple Arguments in C++ Functions

Our functions can be set up to receive multiple arguments. To do this, we just define more variables in our parameter list, separated by a comma ,

1int AddNumbers(int x, int y, int z) {
2  return x + y + z;
3}
4

And we do the same thing with the arguments we pass in:

1// This will return 6
2AddNumbers(1, 2, 3);
3

The parameters do not need to match the return type of the function, nor do they need to match the type of other parameters:

1int Health { 100 };
2
3void TakeDamage(int Damage, bool isPhysicalDamage) {
4  // Physical damage is reduced to 50% by armour
5  Health -= isPhysicalDamage ? Damage / 2 : Damage;
6}
7
8TakeDamage(50, true);
9

Argument Type Conversion

If we try to pass an argument of the incorrect data type, C++ will try to do the implicit conversion we saw in previous lessons.

For example, if we try to pass an argument of 5 (an int) into a parameter that has a type of float, the parameter will be 5.0f.

If we attempt to pass a data type that cannot be converted to what the parameter expects, the code will not compile, and we’ll be notified of the error.

1// Float can be converted to int, so this will do 25 damage
2TakeDamage(25.0f);
3
4// Bool can be converted to int, so this will do 1 damage
5TakeDamage(true);
6
7// String cannot be converted to int, so this will be an error
8TakeDamage("Hello!");
9
10// This will also be an error - we have to provide something
11TakeDamage();
12

1int Multiply(float x, float y) {
2  return x * y;
3}
4
5int Result { Multiply(2, 2.5f) };
6

Optional Arguments in C++ Functions

In our examples above, we added a second argument to the TakeDamage function to denote whether the damage was physical or magical.

1void TakeDamage(int Damage, bool isPhysicalDamage) {
2  // Physical damage is reduced to 50% by armour
3  Health -= isPhysicalDamage ? Damage / 2 : Damage;
4}
5

This did make our function more flexible, but might make it a bit less intuitive to use. Often, we'll want our function to behave a certain way by default, but also to give callers the option to override that default behavior.

For scenarios like this, we can define optional arguments. For example, we can have our function assume that damage is physical, but still let callers overrule that assumption if they need to:

1// This will assumed to be physical damage
2TakeDamage(50);
3
4// This will override that assumption
5TakeDamage(50, false);
6

The way we set up an optional parameter is to give it a default value in our parameter list. This is the value that the parameter will have, if it is not provided as an argument when the function is called.

We do this using the = operator within the parameter list:

1void TakeDamage(int Damage, bool isPhysical = true) {
2  Health -= isPhysical ? Damage / 2 : Damage;
3}
4
5// This still works, but the true is unnecessary
6TakeDamage(50, true);
7
8// It is equivalent to this:
9TakeDamage(50);
10
11// To override the default parameter:
12TakeDamage(50, false);
13

We can have any number of optional parameters:

1void TakeDamage(
2  int Damage,
3  bool isPhysicalDamage = true,
4  bool canBeLethalDamage = true,
5) {
6  // body here
7}
8

However, we cannot have required parameters after optional parameters.

We will see workarounds for this soon, but for now, just note that something like this would be impossible:

1void TakeDamage(
2  int Damage,
3  bool isPhysicalDamage = true,
4  bool canBeLethalDamage
5) {
6  // body here
7}
8

To understand why optional parameters cannot come before required parameters, consider what would happen were we to call this function with an argument list like this:

1TakeDamage(50, false);
2

What are we setting to false here? Is it isPhysicalDamage or canBeLethalDamage? Our intent is not clear. So, the compiler does not allow our function to be set up that way.

1int Multiply(int x, int y = 3) {
2  return x * y;
3}
4
5int Result { Multiply(2) };
6

1int Multiply(int x = 2, int y) {
2  return x * y;
3}
4
5int Result { Multiply(2) };
6

Using Expressions as Arguments

In the previous examples, all our arguments were passed as "literal" values, for example, 25 and true.

In reality, we can use any expression that results in a value of the correct type, for example:

1bool isWizard { false };
2
3// This will be equivalent to TakeDamage(50, true)
4TakeDamage(25 * 2, !isWizard);
5

Our arguments can also be determined by calls to other functions. As long as that other function returns something of the correct data type, or something that can be converted to the correct data type, we can use it:

1int CalculateDamage() {
2  return 25;
3};
4TakeDamage(CalculateDamage(), true);
5

We can even compose functions with themselves:

1// Will become AddNumbers(1, 2, 12)
2// Which will become 15
3AddNumbers(1, 2, AddNumbers(3, 4, 5));
4

1int Multiply(int x, int y = 3) {
2  return x * y;
3}
4
5int Result { Multiply(2, Multiply(5)) };
6

Parameter Names and Variable Names are not Related

Frequently, the value we want to use in an argument of a function is simply stored in a variable:

1int DamageToInflict { 50 };
2void TakeDamage(int Damage) {
3  // Do stuff
4}
5TakeDamage(DamageToInflict)
6

This example is often a point of confusion, as the names do not match up. We created a variable called DamageToInflict and passed it to a function. But the name within the function was different - it was called Damage.

What we call the variable outside the function does not correlate with what we call the parameter. Whilst they might contain the same value, they are two totally different variables.

Arguments are not mapped to parameters by their name, rather, they are mapped by their order.

Parameter and Argument Order

When we call a function, the first argument maps to the first parameter; the second argument maps to the second parameter, and so on.

We can see this here:

1int x { 5 };
2int y { 2 };
3int SubtractNumbers(int a, int b) {
4  return a - b;
5}
6
7// This will be 3
8int Result1 = SubtractNumbers(x, y);
9
10// This will be -3
11int Result2 = SubtractNumbers(y, x);
12

If these results make sense, perhaps we can make things slightly more complicated to solidify the point. Lets rename our function parameters to also be called x and y:

1int x { 5 };
2int y { 2 };
3int SubtractNumbers(int x, int y) {
4  return x - y;
5}
6
7// This will be 3
8int Result1 = SubtractNumbers(x, y);
9
10// This will be -3
11int Result2 = SubtractNumbers(y, x);
12

We now have variables called x and y both outside and inside the function. However, the thing to note here is that this does not change either of the results.

This is because they're different variables - the x on line 1 is not the same x that is on lines 3 and 4.

Having "shadowed variables" like this is generally not a good practice. It is something to avoid in our code because it can cause confusion.

However, it is totally valid C++, and we still need to understand why it works. The x and y outside the functions are different variables to those inside. Whilst they have the same name, the exist in different scopes.

Scopes will be the topic of our next lesson.

1int x { 1 };
2int y { 3 };
3
4int Subtract(int x, int y) {
5  return x - y;
6}
7
8int Result { Subtract(y, x) };
9

This concept is quite confusing, so don't worry if the code and answer in the previous question didn't make sense.

The next lesson explores this topic in more detail, and will help build our understanding.