1.4a — A first look at function parameters and ... https://www.learncpp.com/cpp-tutorial/1-4a-a-firs...

1.4a — A first look at

function parameters and
arguments
BY ALEX ON JANUARY 25TH, 2015 | LAST
MODIFIED BY ALEX ON NOVEMBER 5TH, 2018

Function parameters and arguments

In the previous lesson, you learned that a

function can return a value back to the caller via
the function’s return value.

In many cases, it is useful to be able to pass

information to a function being called, so that
the function has data to work with. For example, if we wanted to write a function to add two numbers, we
need a way to tell the function which two numbers to add when we call it. Otherwise, how would the
function know what to add? We do that via function parameters and arguments.

A function parameter is a variable used in a function where the value is provided by the caller of the
function. Function parameters are placed in between the parenthesis after the function identifier, with
multiple parameters being separated by commas.

Here’s some examples of functions with different numbers of parameters:

1 // This function takes no parameters

2 // It does not rely on the caller for anything
3 void doPrint()
4 {
5     std::cout << "In doPrint()" << std::endl;
6 }
7
8 // This function takes one integer parameter named x
9 // The caller will supply the value of x
10 void printValue(int x)
11 {
12     std::cout << x  << std::endl;
13 }
14
15 // This function has two integer parameters, one named x, and one named y
16 // The caller will supply the value of both x and y
17 int add(int x, int y)
18 {
19     return x + y;
20 }

Each function’s parameters are only valid within that function. So even though printValue() and add() both
have a parameter named x, these parameters are considered separate and do not conflict.

An argument is a value that is passed from the caller to the function when a function call is made:

1 printValue(6); // 6 is the argument passed to function printValue()

2 add(2, 3); // 2 and 3 are the arguments passed to function add()

Note that multiple arguments are also separated by commas. The number of arguments must match the

1 of 10 19/11/18, 7:21 PM
1.4a — A first look at function parameters and ... https://www.learncpp.com/cpp-tutorial/1-4a-a-firs...

number of function parameters. Otherwise, the compiler will throw an error.

How parameters and arguments work together

When a function is called, all of the parameters of the function are created as variables, and the value of
each of the arguments is copied into the matching parameter. This process is called pass by value.

For example:

1 #include <iostream>
2
3 // This function has two integer parameters, one named x, and one named y
4 // The values of x and y are passed in by the caller
5 void printValues(int x, int y)
6 {
7     std::cout << x << std::endl;
8     std::cout << y << std::endl;
9 }
10
11 int main()
12 {
13     printValues(6, 7); // This function call has two arguments, 6 and 7
14
15     return 0;
16 }

When printValues() is called with arguments 6 and 7, printValues’s parameter x is created and assigned
the value of 6, and printValues’s parameter y is created and assigned the value of 7.

This results in the output:

6
7

How parameters and return values work together

By using both parameters and a return value, we can create functions that take data as input, do some
calculation with it, and return the value to the caller.

Here is an example of a very simple function that adds two numbers together and returns the result to the
caller.

1 #include <iostream>
2
3 // add() takes two integers as parameters, and returns the result of their sum
4 // The values of x and y are determined by the function that calls add()
5 int add(int x, int y)
6 {
7     return x + y;
8 }
9
10 // main takes no parameters
11 int main()
12 {
13     std::cout << add(4, 5) << std::endl; // Arguments 4 and 5 are passed to funct
14 ion add()
15     return 0;
}

2 of 10 19/11/18, 7:21 PM
1.4a — A first look at function parameters and ... https://www.learncpp.com/cpp-tutorial/1-4a-a-firs...

When function add() is called, parameter x is assigned the value 4, and parameter y is assigned the value
5.

The function add() then evaluates x + y, which is the value 9, and returns this value back to function main().
This value of 9 is then sent to cout (by main()) to be printed on the screen.

Output:

In pictorial format:

More examples

Let’s take a look at some more function calls:

1 #include <iostream>
2
3 int add(int x, int y)
4 {
5     return x + y;
6 }
7
8 int multiply(int z, int w)
9 {
10     return z * w;
11 }
12
13 int main()
14 {
15     std::cout << add(4, 5) << std::endl; // within add(), x=4, y=5, so x+y=9
16     std::cout << multiply(2, 3) << std::endl; // within multiply(), z=2, w=3, so
17 z*w=6
18
19     // We can pass the value of expressions
20     std::cout << add(1 + 2, 3 * 4) << std::endl; // within add(), x=3, y=12, so x
21 +y=15
22
23     // We can pass the value of variables
24     int a = 5;
25     std::cout << add(a, a) << std::endl; // evaluates (5 + 5)
26
27     std::cout << add(1, multiply(2, 3)) << std::endl; // evaluates 1 + (2 * 3)

3 of 10 19/11/18, 7:21 PM
1.4a — A first look at function parameters and ... https://www.learncpp.com/cpp-tutorial/1-4a-a-firs...

28     std::cout << add(1, add(2, 3)) << std::endl; // evaluates 1 + (2 + 3)

29
    return 0;
}

This program produces the output:

9
6
15
10
7
6

The first two statements are straightforward.

In the third statement, the parameters are expressions that get evaluated before being passed. In this
case, 1 + 2 evaluates to 3, so 3 is passed to x. 3 * 4 evaluates to 12, so 12 is passed to y. add(3, 12)
resolves to 15.

The next pair of statements is relatively easy as well:

1     int a = 5;
2     std::cout << add(a, a) << std::endl; // evaluates (5 + 5)

In this case, add() is called where x = a and y = a. Since a = 5, add(a, a) = add(5, 5), which resolves to 10.

Let’s take a look at the first tricky statement in the bunch:

1     std::cout << add(1, multiply(2, 3)) << std::endl; // evaluates 1 + (2 * 3)

When the function add() is executed, the CPU needs to determine what the values for parameters x and y
are. x is simple since we just passed it the integer 1, so it assigns x=1. To get a value for y, it needs to
evaluate multiply(2, 3) first. The CPU assigns z = 2 and w = 3, and multiply(2, 3) returns the integer value
6. That return value of 6 can now be assigned to the y parameter of the add() function. add(1, 6) returns
the integer 7, which is then passed to cout for printing.

Put less verbosely (where the => symbol is used to represent evaluation):
add(1, multiply(2, 3)) => add(1, 6) => 7

The following statement looks tricky because one of the parameters given to add() is another call to add().

1     std::cout << add(1, add(2, 3)) << std::endl; // evaluates 1 + (2 + 3)

But this case works exactly the same as the above case where one of the parameters is a call to multiply().

Before the CPU can evaluate the outer call to add(), it must evaluate the inner call to add(2, 3). add(2, 3)
evaluates to 5. Now it can evaluate add(1, 5), which evaluates to the value 6. cout is passed the value 6.

Less verbosely:
add(1, add(2, 3)) => add(1, 5) => 6

Conclusion

Parameters are the key mechanism by which functions can be written in a reusable way, as it allows them
to perform tasks without knowing the specific input values ahead of time. Those input values are passed in
as arguments by the caller.

4 of 10 19/11/18, 7:21 PM
1.4a — A first look at function parameters and ... https://www.learncpp.com/cpp-tutorial/1-4a-a-firs...

Return values allow a function to return a value back to the caller.

Quiz

1) What’s wrong with this program fragment?

1 #include <iostream>
2
3 void multiply(int x, int y)
4 {
5     return x * y;
6 }
7
8 int main()
9 {
10     std::cout << multiply(4, 5) << std::endl;
11     return 0;
12 }

2) What two things are wrong with this program fragment?

1 #include <iostream>
2
3 int multiply(int x, int y)
4 {
5     int product = x * y;
6 }
7
8 int main()
9 {
10     std::cout << multiply(4) << std::endl;
11     return 0;
12 }

3) What value does the following program print?

1 #include <iostream>
2
3 int add(int x, int y, int z)
4 {
5     return x + y + z;
6 }
7
8 int multiply(int x, int y)
9 {
10     return x * y;
11 }
12
13 int main()
14 {
15     std::cout << multiply(add(1, 2, 3), 4) << std::endl;
16     return 0;
17 }

4) Write a function called doubleNumber() that takes one integer parameter and returns twice the value
passed in.

5) Write a complete program that reads an integer from the user (using cin, discussed in lesson 1.3a -- A
first look at cout, cin, and endl), doubles it using the doubleNumber() function you wrote for question 4,
and then prints the doubled value out to the console.

5 of 10 19/11/18, 7:21 PM
1.4a — A first look at function parameters and ... https://www.learncpp.com/cpp-tutorial/1-4a-a-firs...

Quiz Answers

To see these answers, select the area below with your mouse.

1) Hide Solution

multiply() is defined as returning void, which means it can’t return a value. Since the function is trying to
return a value, this function will produce a compiler error. The function should return an int.

2) Hide Solution

Problem 1: main() passes one argument to multiply(), but multiply() requires two parameters.

Problem 2: multiply() calculates a value and puts the result in a variable, but never returns the value to
the caller. Because there is no return statement, and the function is supposed to return an int, this will
either produce a compiler error (on some compilers) or unexpected results (on other compilers).

3) Hide Solution

multiply is called where x = add(1, 2, 3), and y = 4. First, the CPU resolves x = add(1, 2, 3), which returns
1 + 2 + 3, or x = 6. multiply(6, 4) = 24, which is the answer.

4) Hide Solution

1 int doubleNumber(int x)
2 {
3     return 2 * x;
4 }

5) Hide Solution

1 #include <iostream>
2
3 int doubleNumber(int x)
4 {
5     return 2 * x;
6 }
7
8 int main()
9 {
10     int x;
11     std::cin >> x;
12     std::cout << doubleNumber(x) << std::endl;
13     return 0;
14 }
15
16 /*
17 // The following is an alternate way of doing main:
18 int main()
19 {
20     int x;
21     std::cin >> x;
22     x = doubleNumber(x);
23     std::cout << x << std::endl;
24     return 0;
25 }
26 */

Note: You may come up with other (similar) solutions for #4 and #5. There are often many ways to do the
same thing in C++.

6 of 10 19/11/18, 7:21 PM