C++ Fundamentals: Hit the ground running with C++, the language that supports tech giants globally

Functions are a core tool in a programmer's toolkit for writing maintainable code. The concept of a function is common in almost every programming language. Functions have different names in various languages: procedures, routines, and many more, but they all have two main characteristics in common:

The programmer can call, or invoke a function when the functionalities provided by the function are needed.

When the function is called, the sequence of instructions is executed. The caller can also provide some data to the function to be used in operations within the program. The following are the main advantages of using functions:

A function declaration has the role of telling the compiler the name, the parameters, and the return type of a function. After a function has been declared, it can be used in the rest of the program.

The definition of the function specifies what operations a function performs.

A declaration is composed of the type of the returned value, followed by the name of the function and by a list of parameters inside a pair of parentheses. These last two components form the signature of the function. The syntax of a function declaration is as follows:

// Declaration: function without body
return_type function_name( parameter list );

If a function returns nothing, then the type void can be used, and if a function is not expecting any parameters the list can be empty.

Let's look at an example of a function declaration:

void doNothingForNow();

Here, we declared a function named doNothingForNow(), which takes no arguments and returns nothing. After this declaration, we can...

The body of a function is a code block that can contain valid statements, one of which is a variable definition. As we learned in Lesson 1, Getting Started, when such a statement appears, the function declares a local variable.

This is in contrast to global variables, which are the variables that are declared outside of functions (and classes, which we will look at in Lesson 3, Classes).

The difference between a local and a global variable is in the scope in which it is declared, and thus, in who can access it.

It is desirable to use local variables over global variables because they enable encapsulation: only the code inside the function body can access and modify the variable, making the variable invisible to the rest of the program. This makes it easy to understand how a variable is used by a...

In the Introduction section, we mentioned that the caller can provide some data to the function. This is done by passing arguments to the parameters of the function.

The parameters that a function accept are part of its signature, so we need to specify them in every declaration.

The list of parameters a function can accept is contained in the parentheses after the function name. The parameters in the function parentheses are comma-separated, composed by a type, and optionally an identifier.

For example, a function taking two integer numbers would be declared as follows:

void two_ints(int, int);

If we wanted to give a name to these parameters, a and b respectively, we would write the following:

void two_ints(int a, int b);

Inside its body, the function can access the identifiers defined in the function signature as if they were declared variables. The values of the function parameters are decided when the function is called.

To call a function that takes a parameter...

A temporary object cannot be passed as an argument for a reference parameter. To accept temporary parameters, we need to use const references or r-value references. The r-value references are references that are identified by two ampersands, &&, and can only refer to temporary values. We will look at them in more detail in Lesson 4, Generic Programming and Templates.

We need to remember that a pointer is a value that represents the location of an object.

Being a value, it means that when we are accepting a parameter as a pointer, the pointer itself is passed as a value.

This means that the modification of the pointer inside the function is not going to be visible to the caller.

But if we are modifying the object the pointer points to, then the original object is going to be modified:

void modify_pointer(int* pointer) {
  *pointer = 1;
  pointer = 0;
}
int main() {
  int a = 0;
  int* ptr = &a;
  modify_pointer(ptr);
  std::cout ...

In the previous chapter, we saw how and when to use references in function parameters and return types. C++ has an additional qualifier, the const qualifier, which can be used independently from the ref-ness (whether the type is a reference or not) of the type.

Let's see how const is used in the various scenarios we investigated when looking at how functions can accept parameters.

Another feature C++ provides to make life easier for the caller when it comes to calling functions are default arguments.

Default arguments are added to a function declaration. The syntax is to add an = sign and supply the value of the default argument after the identifier of the parameter of the function. An example of this would be:

int multiply(int multiplied, int multiplier = 1);

The caller of the function can call multiply either with 1 or 2 arguments:

multiply(10); // Returns 10
multiply(10, 2); // Returns 20

When an argument with a default value is omitted, the function uses the default value instead. This is extremely convenient if there are functions with sensible defaults that callers mostly do not want to modify, except in specific cases.

Imagine a function that returns the first word of a string:

char const * firstWord(char const * string, char separator = ' ').

Most of the time, a word is separated by a whitespace character, but a function can decide whether or not...

One of the goals of functions is to better organize our code. To do so, it is important to give meaningful names to them.

For example, in package management software, there might be a function called sort for sorting packages. As you can see, the name is the same as the function that would sort a list of numbers.

C++ has a feature that allows you to avoid these kinds of problems and groups names together: namespaces.

A namespace starts a scope in which all the names declared inside are part of the namespace.

To create a namespace, we use the namespace keyword, followed by the identifier and then the code block:

namespace example_namespace {
  // code goes here
}

To access an identifier inside a namespace, we prepend the name of the namespace to the name of the function.

Namespaces can be nested as well. Simply use the same declaration as before inside the namespace:

namespace parent {
  namespace child {
    // code goes here
  }
}

To access an identifier inside a namespace, you prepend...

We saw how C++ allows us to write a function that takes parameters either by value or by reference, using const, and organizes them in namespaces.

There is an additional powerful feature of C++ that allows us to give the same name to functions that perform the same conceptual operation on different types: function overloading.

Function overloading is the ability to declare several functions with the same name – that is, if the set of parameters they accept is different.

An example of this is the multiply function. We can imagine this function being defined for integers and floats, or even for vectors and matrices.

If the concept represented by the function is the same, we can provide several functions that accept different kinds of parameters.

When a function is invoked, the compiler looks at all the functions with that name, called the overload set, and picks the function that is the best match for the arguments provided.

The precise rule on how the function is selected is...

In this chapter, we saw the powerful features C++ offers to implement functions.

We started by discussing why functions are useful and what they can be used for, and then we dove into how to declare and define them.

We analyzed different ways of accepting parameters and returning values, how to make use of local variables, and then explored how to improve the safety and convenience of calling them with const and default arguments.

Finally, we saw how functions can be organized in namespaces and the ability to give the same name to different functions that implement the same concept, making the calling code not have to think about which version to call.

In the next chapter, we will look at how to create classes and how they are used in C++ to make building complex programs easy and safe.