Function Arguments and Parameters

We've seen how the execution of our functions can be controlled by conditional statements. These conditional statements allow our functions to 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 program like this:

1#include <iostream>
2using namespace std;
3
4int Health{150};
5
6void TakeDamage(){
7  cout << "Inflicting 50 Damage - ";
8  Health -= 50;
9  cout << "Health: " << Health << '\n';
10}
11
12int main(){
13  TakeDamage();
14  TakeDamage();
15  TakeDamage();
16}

1Inflicting 50 Damage - Health: 100
2Inflicting 50 Damage - Health: 50
3Inflicting 50 Damage - Health: 0

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

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

Function Arguments

Instead, what we could do is pass some data into our function, letting the caller choose how much damage needs to be inflicted. 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 call a function. For example:

1TakeDamage(20); // 20 Damage
2TakeDamage(50); // 50 Damage
3TakeDamage(100); // 100 Damage

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

Function Parameters

When we call a function with an argument, that argument gets passed to a function parameter.

To allow our function to accept an argument, we need to set up a parameter to receive that argument.

We do that between the ( and ) at the top of the function. Similar to a variable, a parameter has a type and a name. The same naming rules and recommendations apply - we should give our parameters meaningful names.

Below, we give our function a parameter of the int type, which we will call Damage:

1void TakeDamage(int Damage) {
2  Health -= 50;
3}

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}

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

1#include <iostream>
2using namespace std;
3
4int Health{150};
5
6void TakeDamage(int Damage){
7  cout << "Inflicting " << Damage << " Damage";
8  Health -= Damage;
9  cout << " - Health: " << Health << '\n';
10}
11
12int main(){
13  TakeDamage(20);
14  TakeDamage(50);
15  TakeDamage(70);
16}

1Inflicting 20 Damage - Health: 130
2Inflicting 50 Damage - Health: 80
3Inflicting 70 Damage - Health: 10

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

Multiple Parameters

By having multiple parameters in our parameter list, our function can receive multiple arguments. We separate multiple parameters using a comma ,

Below, our AddNumbers function has three parameters, all of the int type:

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

When providing arguments for those parameters when we call our function, we also separate them with a comma:

1// This will return 6
2AddNumbers(1, 2, 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 isMagical) {
4  // Magical damage is doubled
5  Health -= isMagical ? Damage * 2 : Damage;
6}
7
8TakeDamage(50, true);

Implicit Conversion of Arguments

If we try to pass an argument of the incorrect data type, the compiler will try to do the same implicit conversion technique 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 the floating point number 5.0.

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

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

Optional Parameters

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

1void TakeDamage(int Damage, bool isMagical) {
2  // Magical damage is doubled
3  Health -= isMagical ? Damage * 2 : Damage;
4}

This made 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 parameters. For example, we can have our function assume that damage is not magical, but still let callers overrule that assumption if they need to:

1// This will assumed to be non-magical damage
2TakeDamage(50);
3
4// This will override that assumption
5TakeDamage(50, true);

To make a parameter optional, we just need to give it a default value in our parameter list. This is the value that the parameter will have if the caller opted not to provide it.

We do this using the = operator within the parameter list. We’ve also moved our parameter list onto a new line. As with most things in C++, we’re free to lay out our code as desired:

1void TakeDamage(
2  int Damage, bool isMagical = false
3) {
4  // Magical damage is doubled
5  Health -= isMagical ? Damage * 2 : Damage;
6}

With this change, callers of our function are free to provide or omit the additional argument as preferred

1// This still works, but the false isn't needed
2TakeDamage(50, false);
3
4// It is equivalent to this:
5TakeDamage(50);
6
7// To override the default parameter:
8TakeDamage(50, true);

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}

However, we cannot have the required parameters after the 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}

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);

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 in the first place.

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

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

Explicitly Using a Default Parameter

We’ve seen how we can use a function’s default parameter simply by omitting the argument in the corresponding position.

Alternatively, we can explicitly use a default parameter by passing an empty set of braces, {}, in that position.

1int Add(int x = 1, int y = 2, int z = 3){
2  return x + y + z;
3}
4
5int main(){
6  // Will return 6
7  Add({}, {}, {}); 
8}

This is required if we want to use default parameters in early positions, but provide a value for a later parameter. Below, we use the function’s default values for parameters x and y, but provide a custom value for z:

1int Add(int x = 1, int y = 2, int z = 3){
2  return x + y + z;
3}
4
5int main(){
6  // Will return 8
7  Add({}, {}, 5);
8}

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 the respective parameter, or one that can be converted to that type. For example:

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

Our arguments can also be determined by calls to other functions. As long as that other function returns something of an appropriate type, we can use it:

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

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));

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

Common Confusion: Parameter Names vs Variable Names

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)

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 different variables.

Arguments are not mapped to parameters by their name, rather, they are mapped by their 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 in the following example:

1#include <iostream>
2using namespace std;
3
4int x{5};
5int y{2};
6
7void SubtractNumbers(int a, int b){
8  cout << "\na = " << a
9    << "\nb = " << b
10    << "\nResult = " << a - b;
11}
12
13int main(){
14  cout << "Calculating " << x << " - " << y;
15  SubtractNumbers(x, y);
16
17  cout << "\n\nCalculating " << y << " - " << x;
18  SubtractNumbers(y, x);
19}

1Calculating 5 - 2
2a = 5
3b = 2
4Result = 3
5
6Calculating 2 - 5
7a = 2
8b = 5
9Result = -3

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

1#include <iostream>
2using namespace std;
3
4int x{5};
5int y{2};
6
7void SubtractNumbers(int x, int y){
8  cout << "\nx = " << x
9    << "\ny = " << y
10    << "\nResult = " << x - y;
11}
12
13int main(){
14  cout << "Calculating " << x << " - " << y;
15  SubtractNumbers(x, y);
16
17  cout << "\n\nCalculating " << y << " - " << x;
18  SubtractNumbers(y, x);
19}

We now have variables called x and y both outside and inside the function. However, our results are the same:

1Calculating 5 - 2
2x = 5
3y = 2
4Result = 3
5
6Calculating 2 - 5
7x = 2
8y = 5
9Result = -3

This is because they're different variables - the x and y outside of our function are not the same as the x and y within our function. They just have the same name. The next lesson in the course is focused on scopes, which discusses this situation in much more detail.

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

This concept is quite confusing, so don't worry if this section didn't make sense.

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

Summary

In this lesson, we explored the fundamental concepts of function arguments and parameters in C++, enhancing our understanding of how to make functions more dynamic and versatile.

Here's a recap of what we've learned:

• Function Arguments and Parameters: We differentiated between arguments (data passed to a function) and parameters (variables within the function that receive the arguments).
• Using Arguments in Functions: Demonstrated how to pass various types of data to functions, allowing them to perform different operations based on the provided arguments.
• Multiple and Optional Parameters: Explored functions with multiple parameters and the use of optional parameters with default values, adding flexibility to function calls.
• Implicit Conversion of Arguments: Discussed how C++ handles different data types when passed as arguments, including implicit conversion and potential compile-time errors.
• Argument Expressions: Showed the versatility of arguments by using expressions, including calls to other functions, as arguments.
• Common Confusions: Addressed a common source of confusion regarding the naming of arguments and parameters, emphasizing their independence and the importance of their order in function calls.

Next Lesson Preview:

In our upcoming lesson, we delve into the concepts of Global and Local Scope.

You'll learn about the scope of variables, how it affects their accessibility within different parts of a program.

Next Lesson

Scope

Learn more about how and when we can access variables, by understanding the importance of the scope in which they exist.

ContinueView Course