Functions in C++

Dr Ian Cornelius

Hello

Hello (1)

Learning Outcomes

Understand how to use functions in C++
Demonstrate the ability to use functions in C++

Functions

Functions (1)

Recap:
- Functions are a block of reusable code that is used to perform a single action
- They provide an aspect of modularity to your code and ensure a high-degree of code reuse
- Help you break a complex problem into smaller portions of code
  - making the script easier to understand

You should already be familiar with functions when you were taught them in the first year programming module. However, let’s have a quick overview or recap on what is meant by the term function.

A function is a block of reusable code that can be used to perform a single action. Functions are useful as they can help a programmer break up their code into smaller, more modular chunks. As the tool is worked upon, the number of functions present may grow with it, and can help organise code and make it more manageable.

Additional benefits to using functions are that it can avoid repetition and makes the code reusable. For example, you may want to capture some sort of input from a user, but this may be called repeatedly overtime, and instead of repeating the same lines of code, you can just call the function to repeat it.

Functions (2)

Creating a Function

Creating a function in C++ is different to Python
Functions in C++ begin with a return type, followed by the function name and a set of brackets (())
The returnType will be the data type of the data being returned from the function
- it can also be set to void if no data is being returned

returnType functionName () {
  ...
}

Now that you are reminded of what a function is and their purpose, let’s have a look at how we would create a function in the C++ programming language. The structure and process of creating a function are a little different in C+= compared to Python. You should recall that in Python we use the def keyword to create our function, and there is no explicit way of telling the Python interpreter the return data type of our function, unless we are using type hinting, and then it is not strictly enforced.

Well in C++, there is no def keyword, and in order to define our function we start with the return data type. This could be anyone of the in-built data types, boolean, string, int or float etc. However, there is a magic data type that can be used, and it is called void. The void keyword tells the compiler that our function does not return a value.

Following on from the return type, we then provide the name of our function, followed by a set of round brackets. This part is similar to what you are used to doing in Python. However, what is different is that after our set of round brackets we use a curly bracket to denote the start of our functions’ body. The function body is where our code that is exclusive to that function will reside, as denoted by the three dots on the screen. Once you have finished providing the code in the body of the function, you then close the curly bracket to denote that this is the end of the function.

Functions (3)

Using a Function

Functions can be called using their function name, followed by a set of brackets
- this is often known as the function caller

void hello() {
  std::cout << "Hello 5062CEM!" << std::endl;
}

#include <iostream>
void hello() {
  std::cout << "Hello 5062CEM!" << std::endl;
}
int main() {
  std::cout << "hello() -> "; 
  hello();
  return 0;
}

hello() -> Hello 5062CEM!

Let’s have a look at creating a function, and then using it in the C++ programming language. On the screen, you will see a function called hello, which prints a string to the terminal window. You will see that the construction of this function follows the structure I explained on the previous slide.

As this function is not too concerned with returning any data, and is just printing a value to the screen, the return type has been set as void. However, if we were returning the string instead, then our return type would have been set to string.

After declaring our return type, we then provide the name of our function. You should always ensure that your function names are descriptive about what is being done. In this case, as I am saying hello, I have decided to call my function hello. After my functions’ name, I then provide a set of round brackets, followed by an opening curly bracket. This then enables me to write some code in the functions’ body. Inside the body of my function, you will see I have used the cout command in order to print a string to the terminal window. A reminder, that the endl command at the end prints a newline.

With our function now created, we can proceed with using our function. To use our function, it is very similar to Python, and all we need to do is provide the function name, followed by a set of round brackets. This is often referred to as a function caller, and when C++ compiles our code, it will call the relevant function and execute the code that resides within it.

In this case, when we call the function hello it will print the string Hello 5062CEM to the terminal window, as you can see from the output in the blue box.

Functions (4)

Returning Values from a Function i

Functions can also return data from inside it using the return statement
Useful if you have performed some operations inside a function and need to use the output in the main body of your code

std::string hello() {
  return "Hello 5062CEM!";
}

#include <iostream>
std::string hello() {
  return "Hello 5062CEM!";
}
int main() {
  std::cout << "hello() -> " << hello() << std::endl;
  return 0;
}

hello() -> Hello 5062CEM!

In C++, functions will often return some form of data that can then be re-used in another function, or the main body of the script. This was briefly touched upon in the earlier slide. However, let’s look at it in a little more detail.

When it comes to returning data from a function in C++, you will need to consider the type of data that is being returned. You will recall from a couple of slides ago that we always declare the return type of function in C++, and therefore, we need to be mindful of this.

The previous function, hello was printing a string to the terminal window. This time, we want to adapt this code, so it returns the data instead. As we know the function is printing a string, then the return type of the function will also be a string. Therefore, we need to modify our function from earlier, and change the return type from void to string.

We then need to move into the body of our function and make a few more changes. Just like Python, to return data from a function, the keyword return is used. Therefore, we need to modify our function that instead of printing to the terminal window, the string “Hello 5062CEM” will be returned instead. Therefore, we replace cout with return, and ensure that we remove the endl part after our string.

That’s it. We have converted our function from not returning data to something that can now return data and be passed through to other functions when necessary. Now whenever we call our function, we have to be mindful that we wrap our function caller inside the cout command to ensure that the data is printed to the screen.

Functions (5)

Returning Values from a Function ii

The returned value from a function can be stored in a variable

#include <iostream>
std::string hello() {
  return "Hello 5062CEM!";
}
int main() {
  std::string result = hello();
  std::cout << "result -> " << result << std::endl;
  return 0;
}

result -> Hello 5062CEM!

Or alternatively, we could create a variable to store our returned string, which could in turn then be used in the cout command to be printed to the terminal window. As you can see from the example on the screen.

In this example, we have created a string called result which would store the data being returned from our function called hello. When we come to print this to the terminal window, instead of using the function hello in our cout command, we instead refer to the variable result and this will then print the stored string to the terminal window.

It is always best practice to store the returned data of a function in a variable, as you can then use this variable to be passed through to a function as an argument. Which leads me nicely onto our next set of slides.

Parameters and Arguments

Parameters and Arguments (1)

Recap:
- Data can be passed through to a function, and these are known as either parameters or arguments
- Parameter and argument can be used for the same thing
  - simply it is data that is passed into a function
- But they do have a slightly different meaning:
  - parameter is the variable listed inside the brackets in the function definition
  - argument is the value that is sent to the function
Parameters are specified after the declaration of the function name and inside the set of round brackets (())
- you are able to add as many parameters as you want, separating them with a comma (,)

returnType functionName (parameter1, parameter2, ...) {
  ...
}

Parameters and arguments. Again, this was introduced to you in the first year programming module. However, to refresh your memory on what is meant by this terminology, we shall have a short recap.

The terminology parameter and argument are often used to describe the same thing, and that is the passing of data through to a function. But they do have a slightly different meaning to a developer. A parameter is the variable that is listed inside the brackets of the function definition whereas an argument refers to the value that is sent to the function.

When it comes to specifying your parameters, they are provided after the declaration of the functions’ name, and inside the set of round brackets. Multiple parameters can be provided, and they are separated by using a comma. An example structure of a function with parameters has been provided on the screen.

Parameters and Arguments (2)

Example: Parameters and Arguments

Create a function called hello
- accepts a single parameter, name of type string
- returns a string
The Function is called with a string provided inside the brackets
- i.e. hello("Ian Cornelius")
The function returns a greeting welcoming the person to the module

std::string hello(std::string name) {
  return "Hello " + name + ", and welcome to 5062CEM!";
}

#include <iostream>
std::string hello(std::string name) {
  return "Hello " + name + ", and welcome to 5062CEM!";
}
int main() {
  std::cout << "hello(\"Ian Cornelius\") -> " << hello("Ian") << std::endl;
  std::cout << "hello(\"Terry Richards\") -> " << hello("Terry") << std::endl;
  std::cout << "hello(\"Daniel Goldsmith\") -> " << hello("Daniel") << std::endl;
  return 0;
}

hello("Ian Cornelius") -> Hello Ian, and welcome to 5062CEM!
hello("Terry Richards") -> Hello Terry, and welcome to 5062CEM!
hello("Daniel Goldsmith") -> Hello Daniel, and welcome to 5062CEM!

Let’s have a look at an example of how parameters and arguments work in a function using the C++ programming language. On the screen, we have an example of a function that returns a string. The function is concerned with taking the name of a person and then concatenating it with a string and returning the data. In order to do this, let’s have a look at how we have structured our function.

As the function is mainly concerned with returning a string, we have declared the return type to be of the type string. This is then followed by the name of the function, which in this instance is hello, followed by a set of round brackets. Inside these round brackets, we need to declare our parameters to accept an argument.

In this instance, we are concerned with accepting the name of a person, and therefore this will be of a string type. Therefore, in our round brackets, we provide the type of data that will be passed through, followed by a variable name, so we can access the data that is being passed through. Therefore, in the round brackets, I have declared the data type, string and then provided a name for our variable, in this case our variable is called name.

We then move inside the body of our function, and we can adapt our string from earlier. This time we want to be able to concatenate (or join) the name of our person to the string “Hello 5062CEM”. To do this, we can use the plus operator to join our string and variable name together. You will see that I have also adapted our message to be more “welcoming” for the user. This time, our return string looks something like: Hello + name + and welcome to 5062CEM!.

Now, when we execute our script, we can see that when we pass through a name to our function (which is known as an argument), the value will be concatenated with our string, and returned to the terminal window. Let’s have a look at the first example, where we are passing through the value “Ian Cornelius”. When this value is passed through, the C++ compiler will join this string with the pre-existing string for it to read: Hello Ian Cornelius, and welcome to 5062CEM!.

This function can then be repeatedly called with different names, and the string will be returned with the appropriate name in-situ, as can be seen in the second and third example with Terry and Dan.

Parameters and Arguments (3)

When calling a function, it must be called with the correct number of arguments
- if you have a function with three arguments, then you have to call the function with three arguments

std::string hello(std::string name, std::string code) {
  return "Hello " + name + " and welcome to " + code + "!";
}

#include <iostream>
std::string hello(std::string name, std::string code) {
  return "Hello " + name + " and welcome to " + code + "!";
}
int main() {
  std::cout << "hello(\"Ian Cornelius\", \"5062CEM\") -> " << hello("Ian", "5062CEM") << std::endl;
  std::cout << "hello(\"Terry Richards\", \"5069CEM\") -> " << hello("Terry", "5069CEM") << std::endl;
  std::cout << "hello(\"Daniel Goldsmith\") -> error: too few arguments to function ‘std::string hello(std::string, std::string)’" << std::endl;
  return 0;
}

hello("Ian Cornelius", "5062CEM") -> Hello Ian and welcome to 5062CEM!
hello("Terry Richards", "5069CEM") -> Hello Terry and welcome to 5069CEM!
hello("Daniel Goldsmith") -> error: too few arguments to function ‘std::string hello(std::string, std::string)’

It is important to remember that when we call a function, the number of arguments provided in the function caller must match the number of functions in the function header. Let’s have a look at our slightly modified function from earlier, whereby we have adapted to the module code.

On the screen, you will see that I have modified our function hello from earlier by adding a second parameter called code. This will accept a string data type for a module code the person is studying. When I call our functions, I must provide the same number of arguments, as there are parameters in the function header.

Just a quick recap, a function header is the construction of our function, that is the return type, name of our function and the brackets storing our parameters.

You will see that when I call our function and place two arguments, then they are executed correctly and display the necessary information to the terminal window. However, when I execute our third example, whereby I have only provided the name of a person, Daniel Goldsmith, you can see that an error is returned.

The error message is quite detailed in telling where we went wrong. In this instance, it is actually telling us that too few arguments have been provided in the function hello and it provides the details on what the function call was expecting us to provide.

This is an important lesson to take on. Always read your error messages in full. This is also applicable to anything else you may do in life, or on this course. The error messages being returned in most cases are quite descriptive about the problem that has occurred, and can easily be fixed by just reading it. However, that is not always the case, and sometimes a good old Google search or browsing StackOverflow may find you an answer on how to fix the problem you are having.

Parameters and Arguments (4)

Default Values

A function can be called without an argument if a default value has been assigned to the parameter
- the default value will only be evaluated once

std::string hello(std::string name, std::string code="5062CEM") {
  return "Hello " + name + " and welcome to " + code + "!";
}

#include <iostream>
std::string hello(std::string name, std::string code="5062CEM") {
  return "Hello " + name + " and welcome to " + code + "!";
}
int main() {
  std::cout << "hello(\"Ian\", \"5062CEM\") -> " << hello("Ian", "5062CEM") << std::endl;
  std::cout << "hello(\"Terry\", \"5069CEM\") -> " << hello("Terry", "5069CEM") << std::endl;
  std::cout << "hello(\"Daniel\") -> " << hello("Daniel") << std::endl;
  return 0;
}

hello("Ian", "5062CEM") -> Hello Ian and welcome to 5062CEM!
hello("Terry", "5069CEM") -> Hello Terry and welcome to 5069CEM!
hello("Daniel") -> Hello Daniel and welcome to 5062CEM!

The last thing I want to touch upon about functions in C++ are default values. These are particularly useful if you happen to forget to include the required number of arguments to match the number of parameters in the function header.

You will see on the screen that I have the same function as earlier, but this time I have provided a default value for the parameter code. Now, whenever a function call is made and an argument is not passed through for our parameter code then the default value 5062CEM will be used instead.

You will have seen from my last slide, that when I called the hello function and only provided the name Daniel Goldsmith an error was returned. However, this time, when we execute the same function with our default value, we are not presented with an error. Instead, the default module code 5062CEM has been used and this meant that an error was not raised due to too few arguments being passed through.

Goodbye

Goodbye (1)

Questions and Support

Questions? Post them on the Community Page on Aula
Additional Support? Visit the Module Support Page
Contact Details:
- Dr Ian Cornelius, ab6459@coventry.ac.uk