Functions

A function is a block of code which only runs when it is called.
You can pass data, known as parameters, into a function.
Functions are used to perform certain actions, and they are important for reusing code:
Define the code once, and use it many times.
Creating Functions
C++ provides some pre-defined functions, such as main(), which is used to execute code.
But you can also create your own functions to perform certain actions.
To create (often referred to as declare) a function, specify the name of the function, followed by parentheses ().

Function Declaration and Definition
A C++ function consist of two parts:
Declaration: the function's name, return type, and parameters (if any)
Definition: the body of the function (code to be executed)

void myFunction() { // declaration // the body of the function (definition) }

Note: If a user-defined function, such as myFunction() is declared after the main() function, an error will occur.

However, it is possible to separate the declaration and the definition of the function - for code optimization.
You will often see C++ programs that have function declaration above main(), and function definition below main().
This will make the code better organized and easier to read

Call a Function

Declared functions are not executed immediately. They are "saved for later use", and will be executed later, when they are called. To call a function, write the function's name followed by two parentheses () and a semicolon ; In the following example, myFunction() is used to print a text (the action), when it is called.

// Create a function void myFunction() { cout << "I just got executed!"; } int main() { myFunction(); // call the function return 0; } // Outputs "I just got executed!"

A function can be called multiple times.


Parameters and Arguments

Information can be passed to functions as a parameter. Parameters act as variables inside the function.
Parameters are specified after the function name, inside the parentheses.
You can add as many parameters as you want, just separate them with a comma

void myFunction(string fname) { cout << fname << " Refsnes\n"; } int main() { myFunction("Liam"); myFunction("Jenny"); myFunction("Anja"); return 0; } // Liam Refsnes // Jenny Refsnes // Anja Refsnes

When a parameter is passed to the function, it is called an argument.
So, from the example above: fname is a parameter, while Liam, Jenny and Anja are arguments.

Multiple Parameters can also be passed through functions.
When no argument is passed, we can also declare default parameters using '=' operator.

void myFunction(string fname, int age=12) { cout << fname << " Refsnes. " << age << " years old. \n"; } int main() { myFunction("Liam", 3); myFunction("Jenny", 14); myFunction("Anja", 30); myFunction("Kane"); return 0; } // Liam Refsnes. 3 years old. // Jenny Refsnes. 14 years old. // Anja Refsnes. 30 years old. // Kane Refsnes. 12 years old.

Return Values:-

The void keyword, used in the previous examples, indicates that the function should not return a value.
If you want the function to return a value, you can use a data type (such as int, string, etc.) instead of void, and use the return keyword inside the function int myFunction(int x, int y) { return x + y; } int main() { int z = myFunction(5, 3); cout << z; return 0; } // Outputs 8 (5 + 3)

Pass by Reference:- (passing the reference of variables)

void swapNums(int &x, int &y) { int z = x; x = y; y = z; } int main() { int firstNum = 10; int secondNum = 20; cout << "Before swap: " << "\n"; cout << firstNum << secondNum << "\n"; // Call the function, which will change the values of firstNum and secondNum swapNums(firstNum, secondNum); cout << "After swap: " << "\n"; cout << firstNum << secondNum << "\n"; return 0; }

Note: Multiple functions can have the same name as long as the number and/or type of parameters are different. (Function Overloading)