C Funktionen meistern: Praktische Beispiele zu Rekursion & Inline-Techniken

Was ist eine Funktion in C?

Funktion in C-Programmierung ist ein wiederverwendbarer Codeblock, der ein Programm leichter verständlich, testbar und änderbar macht, ohne das aufrufende Programm zu ändern. Funktionen teilen den Code und modularisieren das Programm für bessere und effektivere Ergebnisse. Kurz gesagt: Ein größeres Programm wird in verschiedene Unterprogramme aufgeteilt, die als Funktionen bezeichnet werden.

Wenn Sie ein großes Programm in verschiedene Funktionen aufteilen, wird es einfach, jede Funktion einzeln zu verwalten. Tritt ein Fehler auf, können Sie fehlerhafte Funktionen leicht untersuchen und nur diese korrigieren. Funktionen können einfach aufgerufen und verwendet werden, wann immer sie benötigt werden, was automatisch Zeit und Speicher spart.

In diesem Tutorial lernen Sie:

• Bibliotheks- vs. benutzerdefinierte Funktionen
• Funktionsdeklaration
• Funktionsdefinition
• Funktionsaufruf
• Funktionsargumente
• Variablen-Gültigkeitsbereich (Scope)
• Statische Variablen
• Rekursive Funktionen
• Inline-Funktionen

Bibliotheks- vs. benutzerdefinierte Funktionen

Jedes C-Programm hat mindestens die main-Funktion als Startpunkt. Ein Programm kann beliebig viele Funktionen haben.

In C werden Funktionen in zwei Typen unterteilt:

1. Bibliotheksfunktionen
2. Benutzerdefinierte Funktionen

Der Unterschied: Für Bibliotheksfunktionen müssen wir keinen Code schreiben. Sie sind bereits in Header-Dateien vorhanden, die wir am Programmstart einbinden. Sie rufen nur den Funktionsnamen mit korrekter Syntax auf. printf, scanf sind Beispiele.

Benutzerdefinierte Funktionen erfordern, dass wir den Funktionsrumpf schreiben und die Funktion aufrufen, wann immer wir sie benötigen. Eine benutzerdefinierte Funktion in C wird immer vom Benutzer geschrieben, kann aber später Teil der C-Bibliothek werden – ein großer Vorteil von C.

C-Funktionen gliedern sich in drei Aktivitäten:

1. Funktionsdeklaration
2. Funktionsdefinition
3. Funktionsaufruf

Funktionsdeklaration

Funktionsdeklaration bedeutet, den Namen einer Funktion anzugeben. Sie ist zwingend für die Verwendung von Funktionen im Code. Bei der Deklaration geben wir nur den Namen der Funktion an, die wir im Programm verwenden wollen, ähnlich wie bei Variablendeklaration. Eine Funktion kann nicht verwendet werden, bevor sie deklariert ist. Eine Funktionsdeklaration wird auch „Funktions-Prototyp“ genannt.

Funktionsdeklarationen (Prototypen) erfolgen meist oberhalb der main()-Funktion und haben die allgemeine Form:

return_data_type function_name (data_type arguments);

• return_data_type: Datentyp des Werts, den die Funktion an den Aufrufer zurückgibt.
• function_name: gefolgt von Klammern.
• Argumente mit ihren Datentyp-Deklarationen optional in Klammern.

Beispiel – Deklaration einer add-Funktion zur Berechnung der Summe zweier Integer:

#include <stdio.h>
/* Funktionsdeklaration */
int add(int a, int b);
/* Ende Funktionsdeklaration */
int main() {

Beachten Sie, dass eine Funktion nicht zwingend einen Wert zurückgeben muss. In diesem Fall wird das Schlüsselwort void verwendet.

Beispiel: void output_message(); zeigt an, dass die Funktion keinen Wert zurückgibt.

Funktionsdefinition

Funktionsdefinition bedeutet, den Körper der Funktion zu schreiben. Ein Funktionskörper besteht aus Anweisungen, die eine spezifische Aufgabe ausführen. Er kann aus einer einzelnen Anweisung oder einem Block bestehen. Er ist ebenfalls zwingend.

int add(int a, int b) // Funktionskörper
{
    int c;
    c = a + b;
    return c;
}

Funktionsaufruf

Ein Funktionsaufruf bedeutet, eine Funktion aufzurufen, wann immer sie im Programm benötigt wird. Bei Aufruf führt sie die Operation aus, für die sie entworfen wurde. Ein Funktionsaufruf ist optional im Programm.

result = add(4, 5);

Hier der vollständige Code:

#include <stdio.h>
int add(int a, int b); // Funktionsdeklaration
int main() {
    int a = 10, b = 20;
    int c = add(10, 20); // Funktionsaufruf
    printf("Addition:%d\n", c);
    getch();
}
int add(int a, int b) // Funktionskörper
{
    int c;
    c = a + b;
    return c;
}

Ausgabe:

Addition:30

Funktionsargumente

Argumente einer Funktion empfangen die nötigen Werte beim Funktionsaufruf. Sie werden nach Position zugeordnet: erstes Argument an ersten Parameter, zweites an zweiten, usw.

Standardmäßig werden Argumente call-by-value übergeben – eine Kopie der Daten wird der aufgerufenen Funktion übergeben. Die tatsächlich übergebene Variable ändert sich nicht.

Beispiel – Parameter call-by-value:

int add(int x, int y);
int main() {
    int a = 5, b = 10, result;
    result = add(a, b);
    printf("%d + %d = %d\n", a, b, result);
    return 0;
}
int add(int x, int y) {
    x += y;
    return x;
}

Ausgabe:

5 + 10 = 15

Beachten Sie: Die Werte von a und b, die an add übergeben wurden, änderten sich nicht, da nur ihr Wert in Parameter x kopiert wurde.

Variablen-Gültigkeitsbereich (Variable Scope)

Variablen-Gültigkeitsbereich bedeutet die Sichtbarkeit von Variablen innerhalb des Programmcodes.

In C sind Variablen, die innerhalb einer Funktion deklariert sind, lokal zu diesem Codeblock und können außerhalb der Funktion nicht referenziert werden. Variablen, die außerhalb aller Funktionen deklariert sind, sind global und vom gesamten Programm zugreifbar. Konstanten, die mit #define am Programmstart deklariert sind, sind im gesamten Programm zugreifbar.

Beispiel – Globaler Variablenzugriff aus main und benutzerdefinierter Funktion:

#include <stdio.h>
int global = 1348;
void test();
int main() {
    printf("from the main function : global =%d \n", global);
    test();
    return 0;
}
void test() {
    printf("from user defined function : global =%d \n", global);
}

Ergebnis:

from the main function : global =1348
from user defined function : global =1348

1. Globale Integer-Variable mit Initialwert 1348 deklariert.
2. test()-Funktion deklariert und definiert, die weder Argumente annimmt noch Wert zurückgibt. Sie gibt nur die globale Variable aus, um zu zeigen, dass globale Variablen überall zugreifbar sind.
3. Globale Variable in main ausgegeben.
4. test-Funktion aufgerufen, um globale Variable auszugeben.

In C verhalten sich Funktionsparameter wie lokale Variablen, die beim Verlassen der Funktion zerstört werden.

Bei Verwendung globaler Variablen Vorsicht walten lassen, da sie zu Fehlern führen und sich überall im Programm ändern können. Sie sollten vor Verwendung initialisiert werden.

Statische Variablen

Statische Variablen haben lokalen Gültigkeitsbereich, werden aber beim Verlassen der Funktion nicht zerstört. Daher behält eine statische Variable ihren Wert für immer und kann beim erneuten Betreten der Funktion zugegriffen werden. Eine statische Variable wird bei Deklaration initialisiert und benötigt das Präfix static.

Programm mit statischer Variable:

#include <stdio.h>
void say_hi();
int main() {
    int i;
    for (i = 0; i < 5; i++) {
        say_hi();
    }
    return 0;
}
void say_hi() {
    static int calls_number = 1;
    printf("Hi number %d\n", calls_number);
    calls_number++;
}

Ausgabe:

Hi number 1
Hi number 2
Hi number 3
Hi number 4
Hi number 5

Rekursive Funktionen

Betrachten Sie die Fakultät einer Zahl: 6! = 6 × 5 × 4 × 3 × 2 × 1.

Diese Berechnung erfolgt durch wiederholtes Berechnen von fact * (fact - 1), bis fact gleich 1 ist.

Eine rekursive Funktion ruft sich selbst auf und enthält eine Abbruchbedingung, um die rekursiven Aufrufe zu beenden. Bei der Fakultätsberechnung ist die Abbruchbedingung fact == 1. Rekursion funktioniert durch „Stapeln“ von Aufrufen, bis die Abbruchbedingung erfüllt ist.

Beispiel:

#include <stdio.h>
int factorial(int number);
int main() {
    int x = 6;
    printf("The factorial of %d is %d\n", x, factorial(x));
    return 0;
}
int factorial(int number) {
    if (number == 1) return 1; /* Abbruchbedingung */
    else return (number * factorial(number - 1));
}

Ausgabe:

The factorial of 6 is 720

1. Rekursive Fakultätsfunktion deklariert, die Integer-Parameter annimmt und Fakultät zurückgibt. Sie ruft sich selbst auf und verringert die Zahl, bis die Basiskondition erreicht ist. Dann werden die zuvor generierten Werte multipliziert und der finale Fakultätswert zurückgegeben.
2. Integer-Variable mit Wert 6 deklariert und initialisiert, dann Fakultät durch Aufruf der Funktion ausgegeben.

Betrachten Sie das folgende Diagramm, um den rekursiven Mechanismus besser zu verstehen – Aufrufe der Funktion sich selbst bis Basiskasus, dann Sammlung der vorherigen Werte:

Inline-Funktionen

Funktionen in C speichern häufig verwendete Anweisungen und modularisieren das Programm.

Bei jedem Funktionsaufruf springt der Instruktionszeiger zur Funktionsdefinition. Nach Ausführung fällt er zurück zur Anweisung, von der er gesprungen ist.

Bei Funktionsnutzung benötigen wir einen zusätzlichen Zeigerkopf, um zur Definition zu springen und zurückzukehren. Um diesen Overhead zu eliminieren, nutzen wir Inline-Funktionen.

Bei einer Inline-Funktion wird der Funktionsaufruf direkt durch den eigentlichen Programmcode ersetzt. Es gibt keinen Sprung, da alle Operationen innerhalb der Inline-Funktion ausgeführt werden.

Inline-Funktionen werden meist für kleine Berechnungen verwendet. Sie eignen sich nicht für große Berechnungen.

Eine Inline-Funktion ähnelt einer normalen Funktion, außer dass das Schlüsselwort inline vor dem Funktionsnamen steht. Syntax:

inline function_name() {
    // Funktionsdefinition
}

Programm zur Implementierung einer Inline-Funktion:

inline int add(int a, int b) // Inline-Funktionsdeklaration
{
    return (a + b);
}
int main() {
    int c = add(10, 20);
    printf("Addition:%d\n", c);
    getch();
}

Ausgabe:

Addition: 30

Das obige Programm demonstriert die Verwendung einer Inline-Funktion zur Addition zweier Zahlen. Die Addition wird innerhalb der Inline-Funktion zurückgegeben, ohne zusätzliche Zeilen. Beim Funktionsaufruf übergeben wir nur die Werte, auf die wir die Addition anwenden wollen.

Zusammenfassung

• Eine Funktion ist ein Mini-Programm oder Unterprogramm.
• Funktionen modularisieren das Programm.
• Bibliotheks- und benutzerdefinierte Funktionen sind zwei Typen.
• Eine Funktion besteht aus Deklaration, Körper und Aufruf.
• Funktionsdeklaration und Körper sind zwingend.
• Funktionsaufruf kann optional sein.
• C-Programm hat mindestens eine Funktion: main().
• Jede Funktion hat Namen, Rückgabetyp (oder void), Parameter.
• Jede Funktion muss in Ihrem C-Programm definiert und deklariert sein.
• Beachten Sie: Normale Variablen in einer C-Funktion werden zerstört, sobald wir den Funktionsaufruf verlassen.
• Argumente, die an eine Funktion übergeben werden, ändern sich nicht, da sie call-by-value übergeben werden, nicht call-by-reference.
• Variablen-Gültigkeitsbereich bezieht sich auf Sichtbarkeit von Variablen im Programm.
• Es gibt globale und lokale Variablen in C.