Table of Contents

Every programming language allows functions to be created and used. A function is a group of statements that can be reused. It allows us to write code that is clean and manageable. A function can be either user-defined or built-in (predefined).

User-defined functions are those that are written by programmers, not but the language creators. On the other hand, Built-in functions are predefined functions of a language.

Benefits of Using Functions

Stores a block of code and makes it reusable across one or multiple programs.
Eliminates redundant code by storing it in one single place.
Saves time and cost by making the code easier to debug, maintain and update.

Defining Functions

To use functions in your program, you must first define them. Defining a function allows us to specify the behavior and code for the function.

Function declaration Syntax

The syntax for defining a function in C++ is:

return_type function_name() {
  // function body...
}

Function Parts

A function definition has different parts as explained below:

1. Return Type

All functions can optionally return some value on successful execution. The data type of value that the function returns must match the return type of the function.

A function that does not return a value is declared as void function.

2. Function Name

The name of the function must be a valid identifier. It follows the same rules for naming variables in C++.

3. Function Body

The function body contains the code that we want to execute when the function is used.

Example of a function that reads and prints out a number:

void print() {
  int num;
  cout << " Enter a number: ";
  cin >> num;
  cin << " The entered number is: " << num;
}

Declaring Functions

In C++, declaring a function is pretty similar to declaring a variable which informs the proper way to the compiler on how to call it.

A function can be defined in two locations:

1. Before main()

If we define a function before main(), it acts both as a declaration and definition.

return_type function_name() {
  // function body
}
void main() {
  // use the function
  function_name()
}

2. After the main() function.

If the function is defined after main(), we must declare it otherwise the compiler will throw an error. Declaring a function specifies the return type and the function name.

// declaration just specifies the function.
return_type function_name();
void main() {
  // use the function
  function_name()
}
// definition contains the function body
return_type function_name() {
  // function body
}

Using Functions

To use user-defined functions, we need to invoke/call them. In programming, executing a function is known as invoking or calling it.

We can invoke a function by specifying its name and putting a pair of parenthesis:

function_name();

Invoking a function that is not defined will throw an error.

Example:

/* define the function */
void greet() {
  cout << "Welcome, user! ";
  cout << "It's great to see you here. ";
}
int main() {
  /* invoke method in your code where you want */
  greet();
  cout << "From main.";
  /* other code */
}

The code will execute sequentially as the output below:

Welcome, user!
It’s great to see you here.
From main.

Scope in functions

Scope in programming defines the accessibility of variables and other data in a program. Any variable defined inside a function has a functional scope. It can be accessed and used only within the function where it is defined.

Moreover, every time a function is called, a new space in memory is allocated for its variables.

Points to Remember:

Functions help us to group up code and reuse it later.
Functions help to reduce the redundant code and reuse them later.
A Function must be defined or declared before it can be used. A function definition contains three parts – return type, function name, and the function body.
Variables declared inside a function, known as local variables, can only be accessed in that function due to scope rules.

C++ User-Defined Functions