Lernziele

Am Ende dieser Lektion wirst du gelernt haben:

• Verstehen, welchen Zweck Funktionen haben und warum sie in C++ unerlässlich sind.
• Erstellen von Funktionen auf korrekte Weise, um strukturierten Code sicherzustellen.
• Aufrufen von Funktionen innerhalb eines Programms und Verstehen, wie sie ausgeführt werden.
• Unterscheiden zwischen Funktionen, die Werte zurückgeben, und solchen, die lediglich Anweisungen ausführen.
• Vergleichen verschiedener Möglichkeiten, Funktionen zu definieren, und die beste je nach Situation auszuwählen.

Deklaration, Aufruf und Definition von Funktionen

In C++ sind Funktionen wiederverwendbare Codeblöcke, die es ermöglichen, ein Programm modular und organisiert zu strukturieren. Jede Funktion kapselt eine spezifische Aufgabe, was dazu beiträgt, die Klarheit und Wartbarkeit des Codes zu verbessern. Um eine Funktion in einem Programm verwenden zu können, müssen wir drei grundlegende Schritte befolgen: Deklaration, Aufruf und Definition.

Diese drei Konzepte sind wesentlich, und jedes erfüllt einen besonderen Zweck in der Struktur des Codes. Schauen wir uns jedes im Detail an.

1. Deklaration einer Funktion

   Bevor eine Funktion im Code verwendet werden kann, muss der Compiler über ihre Existenz informiert werden. Dies geschieht durch eine Funktionsdeklaration oder ein Prototyp.

   Die Deklaration einer Funktion teilt dem Compiler drei grundlegende Dinge mit:

   • Der Datentyp, den die Funktion zurückgeben wird (oder void, wenn sie nichts zurückgibt).
   • Der Name der Funktion.
   • Die Parameter, die sie akzeptiert (falls vorhanden), zusammen mit ihren Typen.

   Die allgemeine Syntax einer Funktionsdeklaration lautet:

   rueckgabetyp funktionsname (parameterliste);
   

   Die Deklaration der Funktion wird in der Regel vor main() oder in einer Header-Datei .h platziert, wenn wir mit mehreren Dateien arbeiten.

2. Aufruf einer Funktion

   Nachdem eine Funktion deklariert wurde, können wir sie aufrufen, das heißt, sie im Code verwenden, damit sie ausgeführt wird.

   Wenn eine Funktion aufgerufen wird:

   • Wird der in ihrer Definition enthaltene Code ausgeführt.
   • Wenn die Funktion einen Wert zurückgibt, kann dieser in einer Variablen gespeichert oder direkt in einem Ausdruck verwendet werden.
   • Wenn die Funktion vom Typ void ist, führt sie einfach ihre Anweisungen aus, ohne etwas zurückzugeben.

   Die Syntax für den Aufruf einer Funktion besteht einfach darin, ihren Namen zu schreiben, gefolgt von Klammern mit den Argumenten (falls erforderlich):

   funktionsname(argumente);
   

3. Definition der Funktion:

   Schließlich ist die Definition der Funktion der Teil, in dem ihr Verhalten implementiert wird. Hier werden die Anweisungen angegeben, die ausgeführt werden, wenn die Funktion aufgerufen wird.

   Die allgemeine Syntax einer Funktionsdefinition lautet:

   rueckgabetyp funktionsname (parameterliste) {
       // Funktionskörper: auszuführende Anweisungen
       return wert; // (falls die Funktion einen Wert zurückgibt)
   }
   

   Jede Funktionsdefinition muss die folgenden Regeln einhalten:

   • Sie muss mit der Deklaration übereinstimmen (falls diese zuvor angegeben wurde).
   • Wenn die Funktion einen Wert zurückgibt (z. B. int), muss sie eine return-Anweisung mit dem zurückzugebenden Wert enthalten.
   • Wenn die Funktion nichts zurückgibt (void), führt sie einfach ihre Anweisungen aus und benötigt kein return.

Ausführungsfluss

Wenn das Programm ausgeführt wird, werden die Funktionen in der Reihenfolge aufgerufen, in der sie in main() erscheinen. Der Ausführungsfluss ist wie folgt:

1. Der Compiler erkennt die Deklaration der Funktion.
2. In main(), wenn ein Funktionsaufruf gefunden wird, wird die Programmkontrolle an die Definition der Funktion übergeben.
3. Die Funktion führt ihre Anweisungen aus.
4. Wenn die Funktion einen Rückgabewert hat, wird dieser an die Stelle zurückgegeben, an der sie aufgerufen wurde.
5. Der Programmfluss kehrt zu main() oder zu der Funktion zurück, die den Aufruf durchgeführt hat.

Bedeutung der vorherigen Deklaration

Die Deklaration von Funktionen vor ihrer Verwendung ist entscheidend, da der C++-Compiler den Code von oben nach unten verarbeitet. Wenn wir versuchen, eine Funktion aufzurufen, bevor sie definiert oder deklariert wurde, erhalten wir einen Fehler.

Es gibt zwei Hauptmöglichkeiten, dies zu handhaben:

1. Die Funktion vor main() deklarieren und danach definieren (wie wir es bisher gesehen haben).
2. Die Funktion vor main() definieren und so die Notwendigkeit einer vorherigen Deklaration vermeiden.

Beide Ansätze sind gültig, aber der erste ist in großen Programmen nützlicher, in denen sich die Funktionen in verschiedenen Dateien befinden.

Ansatz: Deklarieren – Aufrufen – Definieren

Einer der am häufigsten verwendeten Ansätze zur Strukturierung von Funktionen in C++ ist der von deklarieren – aufrufen – definieren. Nach dieser Logik organisieren wir unseren Code in drei grundlegende Phasen:

1. Deklaration: Der Compiler wird über die Existenz der Funktion informiert, bevor sie verwendet wird. Dabei werden ihr Name, der Rückgabetyp und die Parameter (falls vorhanden) angegeben.
2. Aufruf: Die Funktion wird im Hauptcode (main() in den meisten Fällen) aufgerufen und führt ihren Inhalt aus.
3. Definition: Die Implementierung der Funktion wird im Detail angegeben, wobei festgelegt wird, welche Anweisungen ausgeführt werden, wenn sie aufgerufen wird.

Diese Struktur ermöglicht eine bessere Organisation des Codes und erleichtert dessen Wartung und Skalierbarkeit. Schauen wir uns ein Beispiel an, bei dem wir diesen Ansatz anwenden:

Beispiel: Funktion consoladice()

Im folgenden Code befolgen wir die Sequenz deklarieren – aufrufen – definieren:

#include <iostream>
using namespace std;
// Zuerst deklarieren wir die Funktion
void consoladice();
int main() {
    // Wir rufen die Funktion auf
    consoladice();
    return 0;
}
// Wir definieren die zuvor deklarierte Funktion und beschreiben ihre interne Funktionsweise
void consoladice() {
    cout << "Dies ist eine einfache Zeichenkette oder Literale." << endl;
    cout << "Jetzt zeige ich dir die Zahl fünf. Hier ist sie: " << 5 << endl;
    cout << "Sehen wir, welches Ergebnis wir erhalten, wenn wir 10/5 rechnen. Das Ergebnis ist: " << 10/5 << endl;
    cout << "Eine typische Methode, die Zahl Pi zu approximieren, ist 22/7. Das Ergebnis ist: " << 22/7 << endl;
    cout << "In C++ ist es nicht dasselbe, 22/7 zu schreiben wie 22.0/7, die Behandlung ist unterschiedlich." << endl;
    cout << "Mit dieser einfachen Änderung können wir sehen, dass 22.0/7 gleich " << 22.0/7 << " ist." << endl;
    cout << "Findest du das nicht eine bessere Annäherung?" << endl;
}

Das erwartete Ergebnis dieses Codes ist

Dies ist eine einfache Zeichenkette oder Literale.
Jetzt zeige ich dir die Zahl fünf. Hier ist sie: 5
Sehen wir, welches Ergebnis wir erhalten, wenn wir 10/5 rechnen. Das Ergebnis ist: 2
Eine typische Methode, die Zahl Pi zu approximieren, ist 22/7. Das Ergebnis ist: 3
In C++ ist es nicht dasselbe, 22/7 zu schreiben wie 22.0/7, die Behandlung ist unterschiedlich.
Mit dieser einfachen Änderung können wir sehen, dass 22.0/7 gleich 3.14286 ist.
Findest du das nicht eine bessere Annäherung?

Um den Ansatz deklarieren – aufrufen – definieren besser zu verstehen, konzentrieren wir uns auf drei Schlüsselteile des Codes:

1. Zeile 5: Funktionsdeklaration
   • void consoladice(); teilt dem Compiler mit, dass es an einer bestimmten Stelle im Code eine Funktion mit dem Namen consoladice() geben wird.
   • Es wird angegeben, dass ihr Rückgabetyp void ist, was bedeutet, dass sie keinen Wert zurückgibt.
   • Auch wenn die Implementierung von consoladice() noch nicht bekannt ist, erlaubt diese Deklaration dem Compiler, sie später zu erkennen, wenn sie verwendet wird.
2. Zeile 9: Funktionsaufruf
   • Innerhalb der Funktion main() führt die Zeile consoladice(); die Funktion aus.
   • Zu diesem Zeitpunkt erkennt der Compiler bereits die Existenz von consoladice() dank ihrer vorherigen Deklaration.
   • Wenn die Funktion aufgerufen wird, wird die Programmkontrolle an ihre Definition übergeben, wo ihr Inhalt ausgeführt wird.
3. Zeilen 14 bis 22: Funktionsdefinition
   • Hier befindet sich die detaillierte Implementierung von consoladice(), in der ihre Anweisungen festgelegt sind.
   • In diesem Fall gibt die Funktion mehrere Nachrichten auf der Konsole aus, einschließlich Zahlen und mathematischer Operationen.
   • Ein wichtiger Punkt ist der Unterschied zwischen 22/7 und 22.0/7. Wenn 22/7 verwendet wird, sind beide Zahlen ganze Zahlen, was aufgrund der Ganzzahldivision das Ergebnis 3 liefert. Beim Schreiben von 22.0/7 hingegen wird die Operation in Gleitkommaarithmetik ausgeführt und ergibt 3.14286.

Ansatz: Deklarieren und Implementieren vor dem Aufruf

In C++ gibt es neben dem Ansatz deklarieren – aufrufen – definieren eine weitere gültige Möglichkeit, unsere Funktionen zu strukturieren: deklarieren und implementieren vor dem Aufruf. Diese Methode kombiniert die Deklaration und die Definition in einem einzigen Schritt, bevor die Funktion in main() verwendet wird.

Bei diesem Ansatz wird die Funktion nicht zunächst deklariert und nach main() definiert, sondern direkt an derselben Stelle deklariert und definiert, bevor sie aufgerufen wird. Dies hat den Vorteil, dass eine separate Deklaration vermieden wird und der Code kompakter und in kleinen Programmen leichter lesbar ist.

Die allgemeine Struktur dieses Ansatzes sieht folgendermaßen aus:

// Wir definieren die Funktion vor main()
rueckgabetyp funktionsname(parameterliste) {
    // Funktionskörper
    return wert; // falls notwendig
}
int main() {
    // Funktionsaufruf
    funktionsname(argumente);
}

Da sie vor main() definiert ist, kennt der Compiler sie bereits, wenn sie aufgerufen wird, sodass keine vorherige Deklaration erforderlich ist.

Beispiel: Funktion consoladice() ohne vorherige Deklaration

Sehen wir uns nun ein praktisches Beispiel an, bei dem wir diesen Ansatz anwenden:

#include <iostream>
using namespace std;
// Wir definieren die Funktion, bevor wir sie aufrufen
void consoladice() {
    cout << "Dies ist eine einfache Zeichenkette oder Literale." << endl;
    cout << "Jetzt zeige ich dir die Zahl fünf. Hier ist sie: " << 5 << endl;
    cout << "Sehen wir, welches Ergebnis wir erhalten, wenn wir 10/5 rechnen. Das Ergebnis ist: " << 10/5 << endl;
    cout << "Eine typische Methode, die Zahl Pi zu approximieren, ist 22/7. Das Ergebnis ist: " << 22/7 << endl;
    cout << "In C++ ist es nicht dasselbe, 22/7 zu schreiben wie 22.0/7, die Behandlung ist unterschiedlich." << endl;
    cout << "Mit dieser einfachen Änderung können wir sehen, dass 22.0/7 gleich " << 22.0/7 << " ist." << endl;
    cout << "Findest du das nicht eine bessere Annäherung?" << endl;
}
int main() {
    // Wir rufen die Funktion auf
    consoladice();
    return 0;
}

In diesem Code können wir sehen, dass:

1. Zwischen den Zeilen 5 und 13 die Deklaration und Definition kombiniert werden

   Die Funktion consoladice() wird direkt vor main() definiert, ohne dass eine separate Deklaration erforderlich ist.

2. In Zeile 17 die Funktion innerhalb von main() aufgerufen wird

   Da die Funktion bereits zuvor definiert wurde, erkennt der Compiler sie und erlaubt ihre Ausführung ohne Probleme.

3. Das Ergebnis ist exakt dasselbe

   Auf funktionaler Ebene erzeugt dieser Ansatz dasselbe Verhalten wie der Ansatz deklarieren – aufrufen – definieren, jedoch mit einer kompakteren Struktur.

✅ Vorteile:

• Direkterer und kompakterer Code in kleinen Programmen.
• Erfordert keine vorherige Deklaration, was die Anzahl der Codezeilen reduziert.
• Erleichtert das Lesen in kurzen Skripten, in denen sich alle Funktionen in einer einzigen Datei befinden.

❌ Nachteile:

• In großen Programmen kann die Organisation erschwert werden, wenn viele Funktionen vor main() definiert sind.
• Weniger nützlich bei der Arbeit mit mehreren Dateien (.h und .cpp), da es vorzuziehen ist, die Deklaration in einer separaten Datei zu halten.

Weitergabe des Rückgabewerts

Bis jetzt haben wir mit Funktionen gearbeitet, die lediglich Anweisungen ausführen, ohne ein Ergebnis zurückzugeben. In vielen Fällen ist es jedoch notwendig, dass eine Funktion einen Wert zurückgibt, damit dieser in weiteren Berechnungen verwendet oder in Variablen gespeichert werden kann. Dieser Prozess wird als Weitergabe des Rückgabewerts bezeichnet.

In diesem Abschnitt lernen wir, wie Funktionen funktionieren, die Werte zurückgeben, worin sie sich von void-Funktionen unterscheiden und wie wir diesen Mechanismus in C++ nutzen können.

Praktisches Beispiel: Funktion zur Berechnung der Fläche eines Rechtecks

Um die Weitergabe des Rückgabewerts zu veranschaulichen, implementieren wir eine Funktion, die die Basis und die Höhe eines Rechtecks entgegennimmt und seine Fläche berechnet.

#include <iostream>
using namespace std;
// Funktion, die die Fläche eines Rechtecks berechnet und das Ergebnis zurückgibt
double berechneFlaeche(double basis, double hoehe) {
    return basis * hoehe;
}
int main() {
    double basis, hoehe;
    
    // Wir bitten den Benutzer, die Werte einzugeben
    cout << "Geben Sie die Basis des Rechtecks ein: ";
    cin >> basis;
    cout << "Geben Sie die Höhe des Rechtecks ein: ";
    cin >> hoehe;
    // Wir rufen die Funktion auf und speichern ihr Ergebnis
    double flaeche = berechneFlaeche(basis, hoehe);
    // Wir zeigen das Ergebnis an
    cout << "Die Fläche des Rechtecks beträgt: " << flaeche << endl;
    
    return 0;
}

1. Die Funktion berechneFlaeche() gibt einen Wert zurück
   • Sie erhält zwei Werte (basis und hoehe) als Parameter.
   • Sie berechnet die Fläche durch die Multiplikation basis * hoehe.
   • Sie verwendet return, um das Ergebnis der Operation an den Teil des Programms zurückzugeben, der sie aufgerufen hat.
2. Verwendung des Rückgabewerts in main()
   • Die Werte für basis und hoehe werden vom Benutzer eingegeben.
   • Die Funktion berechneFlaeche() wird aufgerufen, und ihr Ergebnis wird in der Variablen flaeche gespeichert.
   • Schließlich wird das Ergebnis in der Konsole angezeigt.
3. Wesentlicher Unterschied zu einer void-Funktion

   Wenn berechneFlaeche() vom Typ void wäre, müssten wir das Ergebnis direkt innerhalb der Funktion ausgeben, anstatt es an main() zur weiteren Verwendung zurückzugeben.

Beispiel: Funktion, die bestimmt, ob eine Zahl gerade oder ungerade ist

#include <iostream>
using namespace std;
bool istGerade(int zahl) {
    return zahl % 2 == 0;
}
int main() {
    int zahl;
    cout << "Geben Sie eine Zahl ein: "; cin >> zahl;
    if (istGerade(zahl)) {
        cout << "Die Zahl ist gerade." << endl;
    } else {
        cout << "Die Zahl ist ungerade." << endl;
    }
    return 0;
}

Hier gibt die Funktion istGerade() true zurück, wenn die Zahl gerade ist, und false, wenn sie ungerade ist, sodass main() das Ergebnis verwenden kann, um zu entscheiden, welche Nachricht angezeigt wird.

Rekursion: Funktionen, die sich selbst aufrufen

Rekursion ist eine Technik, bei der eine Funktion sich selbst aufruft, um Probleme zu lösen, indem sie sie in kleinere Versionen von sich selbst unterteilt. Sie ist besonders nützlich in Algorithmen wie der Berechnung der Fakultät, der Fibonacci-Reihe und beim Durchlaufen von Datenstrukturen wie Bäumen.

Beispiel: Fakultät einer Zahl

Die Fakultät einer Zahl n ist n!=n\cdot(n-1)\cdot(n-2) \cdots 3 \cdot2 \cdot 1. Diese Formulierung hat eine rekursive Struktur, die wir mathematisch wie folgt darstellen können:

\begin{array}{rl} 0! &=1\\ n! &= n\cdot(n-1)!\\ \end{array}

Unter Berücksichtigung dessen können wir diese Funktion in C++ wie folgt programmieren:

#include <iostream>
using namespace std;
 
int fakultaet(int n) {
    if (n == 0 || n == 1) {
        return 1;
    }
    return n*fakultaet(n - 1);
}
 
int main() {
    int zahl;
    cout << "Geben Sie eine Zahl ein: "; cin >> zahl;
    cout << "Die Fakultät von " << zahl << " ist " << fakultaet(zahl) << endl;
    return 0;
}

In diesem Code:

• Die Funktion fakultaet(n) ruft sich selbst mit n-1 auf, bis sie den Basisfall (n == 0 oder n == 1) erreicht.
• Die Funktion wird rekursiv aufgelöst, indem die Werte multipliziert werden, bis das Ergebnis gefunden ist.

Beispiel: Fibonacci-Zahlen

Die Fibonacci-Zahlen sind diejenigen, die durch die Sequenz 1, 1, 2, 3, 5, 8, 13, \cdots dargestellt werden. Diese Sequenz zeichnet sich dadurch aus, dass jede Zahl gleich der Summe der beiden vorhergehenden ist.

Mathematisch gilt: Wenn fibo(n) die Funktion ist, deren Ergebnisse die Fibonacci-Zahlen sind, dann hat sie die folgende mathematische Struktur:

\begin{array}{rl} fibo(0) &= 1\\ fibo(1) &= 1 \\ fibo(n) &= fibo(n-1) + fibo(n-2) \end{array}

Ein Beispielcode in C++, der die Fibonacci-Zahlen zeigt, ist der folgende:

#include<iostream>
 
using namespace std;
 
int fibo(int zahl){
    if (zahl==0||zahl==1){
        return 1;
        }
    return fibo(zahl-1)+fibo(zahl-2);
    }
 
int main(){
    int x=0, i=0;
    cout << "Geben Sie eine Zahl ein: "; cin >> x;
     
    while (i < x){
        cout <<"Die Fibonacci-Zahl an Position " << i+1 << " ist: " << fibo(i)<<endl;
        i=i+1;
    }   
}

Mehrfache Rückgabe in Funktionen

In C++ kann eine Funktion mehr als einen Wert zurückgeben, indem Strukturen wie std::pair, std::tuple oder Referenzen auf Variablen verwendet werden.

Beispiel: Funktion, die zwei Werte mit std::pair zurückgibt

#include <iostream>
#include <utility> // Für die Verwendung von std::pair
using namespace std;
 
pair<int, int> teilen(int a, int b) {
    return make_pair(a / b, a % b);
}
 
int main() {
    int zaehler=0, nenner=1;
     
    cout << "Geben Sie den Zähler ein: "; cin >> zaehler;
    cout << "Geben Sie den Nenner ein: "; cin >> nenner;
     
    pair<int, int> ergebnis = teilen(zaehler, nenner);
 
    cout << "Quotient: " << ergebnis.first << endl;
    cout << "Rest: " << ergebnis.second << endl;
 
    return 0;
}

Hier gibt die Funktion teilen() zwei Werte zurück: den Quotienten und den Rest einer Ganzzahldivision.

Beispiel: Funktion, die zwei Werte mit std::tuple zurückgibt

#include <iostream>
#include <tuple>
using namespace std;
tuple<int, int, int> operationen(int a, int b) {
    return make_tuple(a + b, a - b, a * b);
}
int main() {
    int summe=0, differenz=0, produkt=0;
    int a=0, b=0;
    
    cout << "Geben Sie eine Zahl ein: "; cin >> a;
    
    cout << "Geben Sie eine weitere Zahl ein: "; cin >> b;
    
    std::tie(summe, differenz, produkt) = operationen(a, b);
    cout << "Summe: " << summe << ", Differenz: " << differenz << ", Produkt: " << produkt << endl;
    return 0;
}

Funktionsüberladung (Overloading)

Die Funktionsüberladung ermöglicht es, mehrere Funktionen mit demselben Namen, aber unterschiedlichen Typen oder Mengen von Parametern zu definieren. Dies verbessert die Lesbarkeit und Wiederverwendbarkeit des Codes.

#include <iostream>
#include <string> // Notwendig für std::string
#include <cmath>
using namespace std;
// Fläche eines Quadrats oder Kreises (Figuren mit einem Wert)
double flaeche(double seite) {
    return seite * seite;
}
// Fläche eines Rechtecks (oder Figuren mit zwei Werten)
double flaeche(double basis, double hoehe) {
    return basis * hoehe;
}
// Fläche eines Dreiecks (oder Figuren mit drei Werten)
double flaeche(double a, double b, double c){
	return 0.25*sqrt((a+b+c)*(a+b-c)*(a-b+c)*(-a+b+c));
}
int main() {
    string figur;
    double ergebnis = 0;
    double l1=0, l2=0, l3=0;
    // Figur abfragen
    cout << "Welche Figur ist es? (quadrat, kreis, rechteck oder dreieck): ";
    cin >> figur;
    // Figur mit if-else auswerten
    if (figur == "quadrat") {
        cout << "Wie lang ist die Seite? "; cin >> l1;
        ergebnis = flaeche(l1);
        cout << "Die Fläche des Quadrats beträgt: " << ergebnis << endl;
    } 
    else if (figur == "rechteck"){
        cout << "Wie lang ist die Basis? "; cin >> l1;
        cout << "Wie hoch ist es? ";cin >> l2;
        ergebnis = flaeche(l1, l2);
        cout << "Die Fläche des Rechtecks beträgt: " << ergebnis << endl;
    } 
    else if (figur == "kreis") {
		l1 = 3.141592653;
        cout << "Wie groß ist der Radius? "; cin >> l2;
        ergebnis = flaeche(l1, l2);
        cout << "Die Fläche des Kreises beträgt: " << ergebnis << endl;
    } 
    else if (figur == "dreieck"){
    	cout << "Wie lang sind seine Seiten?" << endl;
    	cout << "Seite 1: "; cin >> l1;
		cout << "Seite 2: "; cin >> l2;
		cout << "Seite 3: "; cin >> l3;
			
		if ((l1+l2+l3)*(l1+l2-l3)*(l1-l2+l3)*(-l1+l2+l3)<0){
			cout << "Das Dreieck ist unmöglich";
		}	
		else {
			ergebnis = flaeche(l1,l2,l3);
			cout << "Die Fläche des Dreiecks beträgt: " << ergebnis << endl;
		} 			
	}
    else {
        cout << "Ungültige Figur." << endl;
    }
    return 0;
}

Inline-Funktionen in C++

Die inline-Funktionen in C++ bieten einen Mechanismus zur Optimierung der Programmausführung, indem sie die Überlastung durch Funktionsaufrufe reduzieren. Anstatt einen herkömmlichen Aufruf auszuführen, versucht der Compiler, den Code der Funktion direkt an jeder Stelle einzufügen, an der sie aufgerufen wird.

Syntax einer Inline-Funktion

inline rueckgabetyp funktionsname(parameterliste) {
    // Funktionskörper
    return wert; // falls notwendig
}

Durch die Verwendung von inline entfällt die Notwendigkeit, zu einer anderen Speicheradresse zu springen, um die Funktion auszuführen, was die Laufzeit verkürzen kann.

Unterschiede zwischen einer Inline-Funktion und einer herkömmlichen Funktion

Beispiel einer inline-Funktion

#include <iostream>
using namespace std;
inline int quadrat(int x) {
    return x * x;
}
int main() {
    cout << "Das Quadrat von 5 ist: " << quadrat(5) << endl;
    return 0;
}

🔍 Prozess des Compilers:

1. Der Compiler ersetzt den Aufruf quadrat(5) direkt durch 5 * 5.
2. Es gibt keinen Ausführungssprung.
3. Die Berechnung wird in derselben Zeile durchgeführt, in der die Funktion aufgerufen wurde.

Vorteile und Nachteile von inline

✅ Vorteile

• Eliminiert die Überlastung von Funktionsaufrufen: Reduziert die Laufzeit bei kurzen und häufig aufgerufenen Funktionen.
• Erleichtert die Optimierung durch den Compiler: Kann die Leistung verbessern, indem die Verwendung von CPU-Registern und des Stacks vermieden wird.
• Stellt sicher, dass der Funktionscode zur Kompilierzeit verfügbar ist.

❌ Nachteile

• Erhöht die Binärgröße: Wenn die inline-Funktion in einem großen Programm häufig verwendet wird, wird der Code an jedem Aufrufpunkt dupliziert. Dies geschieht, wenn sie in langen oder sehr oft genutzten Funktionen eingesetzt wird.
• Garantiert nicht immer eine Inline-Erweiterung: Der Compiler kann die Anweisung inline ignorieren, wenn er sie nicht für optimal hält.