abracadabra2

You can imagine a function being a "smaller" program to which your main program ('int main') sends input data and uses its produced output data further for the execution. Just like programs do, a function must follow a structure in order to be understood by the computer.

# Examples
A function which calculates twice an integer number n looks as follows :
```cpp
int dublu(int x) {
  return 2 * x;
}
```
If we want a function to calculate a^b (a raised to the power of b) we could opt for the following way :
```cpp
int putere(int a, int b) {
  int rezultat = 1;
  for (int i = 1; i <= b; ++i)
    rezultat *= a;
  return rezultat;
}
```

# The Structure
From the above examples we can deduce what is the structure we should follow when we write a function :
```
tipul_rezultatului nume_functie (lista_parametri) {
  instructiuni
  return rezultat;
}
```
# data types
As programs do, most of the functions produce output data. For being able to further use output data and making the code much easier to be understood by programmers, every function must specify the data type of its own produced result.

This step is very alike with the declaration of variables, every function having a data type.

For instance, a function which calculates the average of 2 rational numbers will be of type 'double' : `double medie(double x, double y) {`

## `function-name`

Similarly to variable's declaration, when we write functions we should name them in order to use them in our program. The rules of naming are the same as variables' are.

It's a good practice to have a suggestive name for the function. It would have been weird to name our function "dividing" or "f" or any other one-letter name instead of "power".

## `parameters-list`

Parameters of a function represent the input data received and the base upon which it calculates the output data.

In contrast to the way we worked until now when we were reading the input from keyboard or external files, data are transmitted to functions throughout variables which are called parameters.

For a better illustration, our function 'medie' from above has two parameters : 'x' and 'y', both of 'double' type. Parameters are separated by commas and we should specify the type of every parameter. The entire list of parameters should be included in parenthesis `(`, `)`.

## `instructions`

As we want to be able to do complicated things in functions, C++ allows us to write any kind of instructions (correct from the perspective of the rules mentioned so far) inside of functions. As we've seen in  function 'power' from above, we can write more instructions in order to calculate the result.

## `return rezultat`

After finishing all the calculations, for being able to point out that we found out the result we should use the 'return' instruction.
After return we write the variable or expression that keeps our result. In order to show that we have finished the instruction we put a semi-colon (';') at the end.

This result could be used further in the program as you have seen in the previous lesson.

### **Pay attention!**
When the program gets to the 'return' instruction the execution of the function is stopped untroubled by any other instruction that follows after 'return'.
```cpp
#include <iostream>
using namespace std;

int f(int a, int b) {
  return a;
  ++b;
  return b;
}

int main() {
  cout<<f(1, 2);
  return 0;
}
```
In the above-stated program, the function will always return the value of 'a' while lines '2' and '3' from the inside of the function will never be executed.


In order to better assimilate the information read the lesson carefully a couple times and be mindful of each question and answer from the quiz.