Functions and Scope

This lesson is a quick introductory tour of functions within C++. It is not intended for those who are entirely new to programming. Rather, the people who may find it useful include:

• those who have completed our introductory course, but want a quick review
• those who are already familiar with programming in another language, but new to C++
• those who have used C++ in the past, but would benefit from a refresher

It summarises several lessons from our introductory course. Anyone looking for more thorough explanations or additional context should consider Chapter 2 of that course.

Previous Course

Intro to Programming with C++

Starting from the fundamentals, become a C++ software engineer, step by step.

View Course

Function Syntax

In C++, a function that is called MyFunction that returns void (ie, nothing) and does nothing looks like this:

1void MyFunction() {}
2

Here are examples of functions that return data. Note that we specify the return type in the function heading:

1float ReturnFloat() {
2  return 5.5f;
3}
4
5bool ReturnBool() {
6  return true;
7}
8

Similar to variables, return statements can be implicitly cast to the return type of the function:

1// This returns the integer 5
2int ReturnInt() {
3  return 5.5f;
4}
5

We invoke functions using their name, and ():

1ReturnFloat();
2

The main Function

Our program needs to define an entry point - the function that will be run when our program is executed.

This is typically a function that returns an int and is called main:

1int main() {
2  return 0;
3}
4

The return value of the main function is an exit code, which describes why our program stopped. Returning 0 indicates the program ran as expected. Any other number is an error code.

If the main function returns nothing, it is assumed to have returned 0. This is a behavior that is specific just to the main function. Every other function must return something of the type specified in its heading, or something that can be converted to that type.

Function Parameters

We define parameters between the () in the function specification. We specify their type and name, and separate multiple parameters using commas:

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

We can define default values for parameters, making them optional. We can pass {} as an argument to use the default value in that position, or omit the arguments entirely if they are at the end:

1int Add(int x = 1, int y = 2) {
2  return x + y;
3}
4
5int main() {
6  // Use no defaults
7  Add(2, 3); // 5
8
9  // Use default for 1st parameter
10  Add({}, 2); // 3
11  
12  // Use default for 2nd parameter
13  Add(2, {}); // 4
14  Add(2); // 4
15
16  // Use default for both parameters
17  Add({}, {}); // 3
18  Add(); // 3
19}
20

Function return types can be set to auto which will ask the compiler to infer what it should be based on the return statements:

1auto Add(int x, int y) {
2  return x + y;
3}
4

Function parameters can also have a type of auto, but this doesn’t mean what we might expect. It creates a function template, which is explained later in this course.

Implicit Argument Conversion

Like with variables, the compiler will attempt to implicitly convert function arguments and return values into the appropriate type. It will only present an error if it cannot do the conversion.

1// Will return 2
2int GetInt() {
3  return 2.5f;
4}
5
6int Add(int x, int y) {
7  return x + y;
8}
9

1// All expressions will return 2
2// they are equivalent to Add(2, 2)
3Add(2, 2);
4Add(2.5f, 2.5f);
5Add(2, 2.5f);
6Add(2.5, 2.5);
7

Function Overloading

It’s possible to have two functions with the same name in the same scope.

The way the compiler determines which function we want to call is by comparing the argument types to the parameter types:

1// Integer Overload
2int Add(int x, int y) {
3  return x + y;
4}
5
6// Float Overload
7float Add(float x, float y) {
8  return x + y;
9}
10
11Add(2, 2); // Calling Integer Overload
12Add(2.5f, 2.5f); // Calling Float Overload
13

If it is ambiguous what function we want to call, the compiler will throw an error. The following is ambiguous because the compiler doesn’t know whether it should convert the first argument or the second argument:

1Add(2, 2.5f); 
2

It could convert the first to a float, and call the overloads that accept a (float, float) argument list. Or, it could convert the second argument to an int, and call the (float, float) overload.

It doesn’t know what we want, so it throws an error.

The following also throws an error, as we provide two double arguments. A double can be converted to either a float or an int so again, we’re being ambiguous:

1Add(2.5, 2.5); 
2

We can remove the ambiguity by explicitly casting our arguments to the desired type.

1// Calling (int, int) Overload
2Add(2, static_cast<int>(2.5f));
3
4// Calling (float, float) Overload
5Add(
6  static_cast<float>(2.5),
7  static_cast<float>(2.5)
8);
9

Forward Declaration

Functions can be declared and defined as separate statements. A function declaration looks the same as a definition, but without the body:

1int Add(int x, int y);
2

A function’s return type, name, and parameter types are often called the function prototype or function signature.

Function prototypes technically don’t need to name their parameters:

1int Add(int, int);
2

But it’s common to include the names, to remind ourselves (or other developers reading our code) what the parameters are for.

Function declarations allow our functions to be called even if they are not yet defined at the place where they are called.

This is referred to as a forward declaration:

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

The difference between a declaration and a definition will become more important as we advance through this course.

Global and Local Scope

Functions and any other block delimited by { and } create a new local scope. Expressions can access their own scope, and any ancestor (parent, grandparent, etc) scope. But they cannot access any descendant (child, grandchild, etc) scopes:

1// Global scope
2int GlobalInt{0};
3
4void MyFunction() {
5  // Local scope
6  int LocalInt{0};
7
8  // This is fine - we're accessing
9  // a variable in the parent scope
10  GlobalInt++;
11}
12
13// This is fine - same scope
14++GlobalInt;
15
16// Not fine - we do not have access
17// to MyFunction's scope from here
18++LocalInt;
19