<sub class="descriptionSection">29-10-2024 08:33:pm // #TODO // [[Programmierung]]</sub>
____
## Was sind Funktionen
Funktionen sind sogenannte "Unterprogramme". Sie führen meistens eine Spezielle aufgabe aus und sind dazu da um Code Redundanz zu vermeiden.
In Cpp definiert man eine Funktion so:
```cpp
<returntype> <functionName> (<parameter1>, <parameter2>,...);
```
Konkretes Beispiel:
```cpp
long addNumbers(int num1, int num2);
```
> [!NOTE] Prototyp und Funktionskörper
> Was wir gerade definiert haben ist streng genommen noch nicht die gesamte Funktion. Wir haben nur den Prototype definiert. Ein Funktionsprototyp informiert den Compiler darüber, dass die Absicht besteht eine Funktion zu nutzen, man hat aber noch nicht den eigentlichen Logikcode der Funktion implementiert.
> Das ist relativ unleserlich und sollte vermieden werden, da sonst andere Developer verwirrt werden könnten.
> Ein Beispiel für einen Anwendungsfall wäre eine Coderichtline in einer FIrma, die besagt, dass in einem C++ File die Main Funktion immer zuerst kommen muss.
> Beispiel für eine Cpp file mit prototyp:
> ```cpp
> //prototyp informiert compiler, dass eine absicht besteht diese funktion später im file zu definieren
> long addNumbers(int num1, int num2);
>
> int main(){
> cout << addNumbers(20, 40) << endl; //expected result: 60, Compiler wirft keinen Fehler, da Funktionsprototyp definiert ist
> };
>
> //eigentliche Funktionsimplementierung
> long addNumbers(int num1, int num2){
> long returnValue = num1 + num2
> return returnValue
> };
> ```
## Parameter
Parameter werte die einer Funktion von einem "Parent Programm" übergeben werden können. Diese sind oft Daten die das Unterprogramm benötigt, da es keinen Zugriff auf Variablen des "Parent Programms" hat (siehe [[Variablen#Variablen Scopes (Gültigkeitsbereich)|Variablen Scopes]]).
Ein Beispiel für eine Funktion mit Parametern:
```cpp
long multiplyNumbers(int num1, int num2); //hier sind die int num1 und int num2 die parameter
```
Wenn Funktionsprototypen genutzt werden dann **müssen die Paremtern im Funktionsprototypen und der Funktionsimplementierung definiert werden**.
### Default Values (Value Parameter)
Einem Parameter kann ein default Value übergeben werden. Ein default value wird nur genutzt wenn der Funktion keine andere Variabel / kein andere Wert für diesen parameter übergeben wird:
```cpp
long multiplyNumbers(int num1, int num2 = 30){
return num1 * num2;
}
int main(){
cout << multiplyNumbers(2) << endl; // Hier wird nur für num1 ein Wert übergeben also wird 30 genutzt für int2 da dies der default ist
}
```
### Formaler Parameter
Formale Parameter sind die Parameter die im Prototypen der Funktion definiert werden:
```cpp
long multiplyNumbers(int formalerParameter1, int formalerParameter2);
```
Normalerweise werden übergebene Werte (Aktuelle Parameter) einfach in die Formale Parameter Variable kopiert, die einzige Ausnahme ist der Default Parameter, da wird der default wert assigned.
### Aktueller Parameter
Der aktuelle Paramter (oder auch Argument) einer Funktion ist der tatsächliche Wert der einer Funktion übergeben wird beim aufrufen:
```cpp
long multiplyNumbers(int num1, int num2){
return num1*num2
}
int main(){
int num1 = 10;
int num2 = 20;
multiplyNumbers(num1, num2) //hier sind num1 und num2 die aktuellen Parameter
multiplyNumbers(10, 20) //hier sind 10 und 20 die aktuellen Parameter
}
```
### Reference Parameter
Normalerweise haben unterprogramme keine Auswirkungen auf die Variablen der Parent Funktion. Sie können keine Übergebenen Variablen ändern, löschen, zuweisen. Wenn das allerdings benötigt wird, dann müssen Reference Parameter genutzt werden. Diese Stellen einen Pointer da, der auf eine andere Speicher addresse zeigt (z.B eine Variable im Parent Programm):
```cpp
void tauschen(int &a, int &b){
int hilf = a ;
a = b;
b = hilf;
}
int main(){
int nummer1 = 10;
int nummer2 = 20;
tauschen(nummer1, nummer2) //tauscht nummer1 und nummer2
//hier sind jetzt nummer1 = 20 und nummer2 = 10
return
}
```
## Aus einer Funktion exiten
Um aus einer Funktion zu springen, muss eine spezielle `return` Anweisung aufgerufen werden. Diese Anweisung nimmt eine Variable vom "Returnwert" einer Funktion (der Variablentyp **vor** dem Funktionnamen). Dieser Returnwert **muss** gegeben werden. Er kann nur ausgelassen werden, wenn der Returnwert einer Funktion "void" ist.
```cpp
int main(){
return 0 //<-- Hier ist die 0 der Returnwert der Funktion "main"
}
```
> [!NOTE] Codestandards für Returns
> In vielen Firmen und Projekten gibt es Codingstandards, die es ermöglichen sollen das jede Funktion einem gleichen Schema folgt.
> In vielen Firmen ist der Standard, dass nur **ein Returnstatement** pro Funktion existieren darf. Bevor man einem Projekt also code contributet sollte darauf geachtet werden wie der Codestandards ist um unnötige diskussionen zu vermeiden.