Function Arguments and Parameters

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

Instead, we could 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.

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 definition. 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) };

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

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

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 is 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 an argument for it.

We do this using = within the parameter list. For presentation reasons, the following example also moves our parameter list onto multiple lines. As with most things in C++, we're free to lay out our code as desired:

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

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 any required parameters after an optional parameter.

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 required parameters cannot come after optional 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 would not be entirely clear, so C++ doesn't permit 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) };

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};
4
5TakeDamage(CalculateDamage(), true);

We can even compose functions with themselves:

1// This 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)) };

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

1int DamageToInflict { 50 };
2
3void TakeDamage(int Damage) {
4  // Do stuff
5}
6
7TakeDamage(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 that ultimately receives the value of that variable. 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 position.

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

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

In this lesson, we explored the fundamental concepts of function arguments and parameters, letting our functions be more versatile. Here's a recap of the key points:

• Arguments and Parameters: Arguments are the data passed to a function, and parameters are the variables within the function that receive those arguments.
• Multiple Arguments: Functions can support multiple arguments - we use a comma , to separate them.
• Optional Arguments: We can give parameters default values using =, which makes the corresponding arguments optional.
• Implicit Conversion of Arguments: We saw how C++ handles different data types when passed as arguments, including implicit conversion and potential compile-time errors.
• Argument Expressions: Arguments don't need to be literal values like 42 or true - we can use expressions such as variable names or other function calls to generate arguments.
• Common Confusions: The name of an argument and it's corresponding parameter are not related. Arguments map to paramaters based on their order within the argument list, not by their names.