Funktionen in der C-Programmierung mit Beispielen: Rekursiv, Inline

Was ist eine Funktion in C?

Die Funktion in der C-Programmierung ist ein wiederverwendbarer Codeblock, der das Verstehen, Testen und Ändern eines Programms erleichtert, 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 ist in verschiedene Unterprogramme unterteilt, die als Funktionen bezeichnet werden

Wenn Sie ein großes Programm in verschiedene Funktionen unterteilen, können Sie jede Funktion einfach einzeln verwalten. Wenn im Programm ein Fehler auftritt, können Sie fehlerhafte Funktionen leicht untersuchen und nur diese Fehler korrigieren. Sie können Funktionen einfach aufrufen und verwenden, wann immer sie benötigt werden, was automatisch Zeit und Platz spart.

In diesem Tutorial lernen Sie:

• Bibliothek Vs. Benutzerdefinierte Funktionen
• Funktionserklärung
• Funktionsdefinition
• Funktionsaufruf
• Funktionsargumente
• Variabler Umfang
• Statische Variablen
• Rekursive Funktionen
• Inline-Funktionen

Bibliothek Vs. Benutzerdefinierte Funktionen

Jedes 'C'-Programm hat mindestens eine Funktion, die die Hauptfunktion ist, aber ein Programm kann eine beliebige Anzahl von Funktionen haben. Die main () - Funktion in C ist ein Startpunkt eines Programms.

Bei der C-Programmierung werden Funktionen in zwei Typen unterteilt:

1. Bibliotheksfunktionen
2. Benutzerdefinierte Funktionen

Der Unterschied zwischen der Bibliothek und benutzerdefinierten Funktionen in C besteht darin, dass wir keinen Code für eine Bibliotheksfunktion schreiben müssen. Es ist bereits in der Header-Datei vorhanden, die wir immer am Anfang eines Programms einfügen. Sie müssen nur den Namen einer Funktion eingeben und zusammen mit der richtigen Syntax verwenden. Printf, scanf sind Beispiele für eine Bibliotheksfunktion.

Während eine benutzerdefinierte Funktion eine Art von Funktion ist, in der wir einen Funktionskörper schreiben und die Funktion aufrufen müssen, wenn wir die Funktion benötigen, um eine Operation in unserem Programm auszuführen.

Eine benutzerdefinierte Funktion in C wird immer vom Benutzer geschrieben, kann aber später Teil der 'C'-Bibliothek sein. Dies ist ein großer Vorteil der C-Programmierung.

C-Programmierfunktionen sind in drei Aktivitäten unterteilt, wie z.

1. Funktionsdeklaration
2. Funktionsdefinition
3. Funktionsaufruf

Funktionserklärung

Funktionsdeklaration bedeutet, einen Namen eines Programms zu schreiben. Es ist ein obligatorischer Teil für die Verwendung von Funktionen im Code. In einer Funktionsdeklaration geben wir nur den Namen einer Funktion an, die wir in unserem Programm wie eine Variablendeklaration verwenden möchten. Wir können eine Funktion nur verwenden, wenn sie in einem Programm deklariert ist. Eine Funktionsdeklaration wird auch als „Funktion genannt Prototyp .“

Die Funktionsdeklarationen (Prototyp genannt) werden normalerweise über der main () -Funktion ausgeführt und haben die allgemeine Form:

return_data_type function_name (data_type arguments);

• Der return_data_type : ist der Datentyp der Wertfunktion, die an die aufrufende Anweisung zurückgegeben wird.
• Dem Funktionsnamen : folgen Klammern
• Argumentnamen mit ihren Datentypdeklarationen werden optional in Klammern gesetzt.

Wir betrachten das folgende Programm, das zeigt, wie eine Cube-Funktion deklariert wird, um den Cube-Wert einer Ganzzahlvariablen zu berechnen

#include /*Function declaration*/int add(int a,b);/*End of Function declaration*/int main() {

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

Beispielsweise gibt die Funktionsdeklaration output_message an, dass die Funktion keinen Wert zurückgibt: void output_message ();

Funktionsdefinition

Funktionsdefinition bedeutet, nur den Körper einer Funktion zu schreiben. Ein Hauptteil einer Funktion besteht aus Anweisungen, die eine bestimmte Aufgabe ausführen. Ein Funktionskörper besteht aus einer einzelnen Anweisung oder einem Anweisungsblock. Es ist auch ein obligatorischer Bestandteil einer Funktion.

int add(int a,int b) //function body{int c;c=a+b;return c;}

Funktionsaufruf

Ein Funktionsaufruf bedeutet, eine Funktion aufzurufen, wann immer sie in einem Programm benötigt wird. Wann immer wir eine Funktion aufrufen, führt sie eine Operation aus, für die sie entworfen wurde. Ein Funktionsaufruf ist ein optionaler Bestandteil eines Programms.

 result = add(4,5);

Hier ist der vollständige Code:

#include int add(int a, int b); //function declarationint main(){int a=10,b=20;int c=add(10,20); //function callprintf("Addition:%d\n",c);getch();}int add(int a,int b) //function body{int c;c=a+b;return c;}

Ausgabe:

Addition:30

Funktionsargumente

Die Argumente einer Funktion werden verwendet, um die erforderlichen Werte vom Funktionsaufruf zu erhalten. Sie sind nach Position abgestimmt; Das erste Argument wird an den ersten Parameter übergeben, das zweite an den zweiten Parameter und so weiter.

Standardmäßig werden die Argumente als Wert übergeben, in dem eine Kopie der Daten an die aufgerufene Funktion übergeben wird. Die tatsächlich übergebene Variable wird nicht geändert.

Wir betrachten das folgende Programm, das die vom Wert übergebenen Parameter demonstriert:

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

Die Programmausgabe lautet:

5 + 10 = 15 

Beachten Sie, dass die Werte von a und b zum Hinzufügen der Funktion nicht geändert wurden, da nur der Wert an den Parameter x übergeben wurde.

Variabler Umfang

Variablenbereich bedeutet die Sichtbarkeit von Variablen innerhalb eines Codes des Programms.

In C sind Variablen, die innerhalb einer Funktion deklariert sind, lokal für diesen Codeblock und können nicht außerhalb der Funktion referenziert werden. Variablen, die außerhalb aller Funktionen deklariert sind, sind jedoch global und für das gesamte Programm zugänglich. Auf Konstanten, die oben in einem Programm mit einem #define deklariert sind, kann vom gesamten Programm aus zugegriffen werden. Wir betrachten das folgende Programm, das den Wert der globalen Variablen sowohl aus der Haupt- als auch aus der benutzerdefinierten Funktion druckt:

#include 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 =1348from user defined function : global =1348

Wir besprechen die Programmdetails:

1. Wir deklarieren eine ganzzahlige globale Variable mit 1348 als Anfangswert.
2. Wir deklarieren und definieren eine test () - Funktion, die weder Argumente akzeptiert noch einen Wert zurückgibt. Diese Funktion gibt nur den globalen Variablenwert aus, um zu demonstrieren, dass auf die globalen Variablen überall im Programm zugegriffen werden kann.
3. Wir drucken die globale Variable innerhalb der Hauptfunktion.
4. Wir rufen die Testfunktion in orde auf, um den globalen Variablenwert zu drucken.

Wenn in C Argumente an Funktionsparameter übergeben werden, fungieren die Parameter als lokale Variablen, die beim Beenden der Funktion zerstört werden.

Wenn Sie globale Variablen verwenden, gehen Sie vorsichtig vor, da dies zu Fehlern führen und sich an einer beliebigen Stelle in einem Programm ändern kann. Sie sollten vor der Verwendung initialisiert werden.

Statische Variablen

Die statischen Variablen haben einen lokalen Bereich. Sie werden jedoch beim Verlassen der Funktion nicht zerstört. Daher behält eine statische Variable ihren Wert für immer bei und kann beim erneuten Eingeben der Funktion aufgerufen werden. Eine statische Variable wird beim Deklarieren initialisiert und benötigt das Präfix static.

Das folgende Programm verwendet eine statische Variable:

#include 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 ++; } 

Das Programm zeigt an:

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

Rekursive Funktionen

Betrachten Sie die Fakultät einer Zahl, die wie folgt berechnet wird 6! = 6 * 5 * 4 * 3 * 2 * 1.

Diese Berechnung erfolgt als wiederholte Berechnung von Fakt * (Fakt -1), bis Fakt gleich 1 ist.

Eine rekursive Funktion ist eine Funktion, die sich selbst aufruft und eine Exit-Bedingung enthält, um die rekursiven Aufrufe zu beenden. Bei der Berechnung der Fakultätszahl ist die Ausgangsbedingung tatsächlich gleich 1. Die Rekursion funktioniert durch "Stapeln" von Aufrufen, bis die Ausgangsbedingung erfüllt ist.

Zum Beispiel:

#include 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); /* exiting condition */elsereturn (number * factorial(number - 1));} 

Das Programm zeigt an:

 The factorial of 6 is 720 

Hier diskutieren wir Programmdetails:

1. Wir deklarieren unsere rekursive Fakultätsfunktion, die einen ganzzahligen Parameter verwendet und die Fakultät dieses Parameters zurückgibt. Diese Funktion ruft sich selbst auf und verringert die Zahl, bis das Verlassen oder die Grundbedingung erreicht ist. Wenn die Bedingung erfüllt ist, werden die zuvor generierten Werte miteinander multipliziert und der endgültige Fakultätswert zurückgegeben.
2. Wir deklarieren und initialisieren eine ganzzahlige Variable mit dem Wert "6" und drucken dann ihren Fakultätswert durch Aufrufen unserer Fakultätsfunktion.

Betrachten Sie das folgende Diagramm, um den rekursiven Mechanismus besser zu verstehen, der darin besteht, die Funktion selbst aufzurufen, bis der Basisfall oder die Stoppbedingung erreicht ist. Danach erfassen wir die vorherigen Werte:

Inline-Funktionen

Die Funktion in der C-Programmierung wird verwendet, um die am häufigsten verwendeten Anweisungen zu speichern. Es dient zur Modularisierung des Programms.

Bei jedem Aufruf einer Funktion springt der Befehlszeiger zur Funktionsdefinition. Nach dem Ausführen einer Funktion greift der Anweisungszeiger auf die Anweisung zurück, von der aus er zur Funktionsdefinition gesprungen ist.

Wann immer wir Funktionen verwenden, benötigen wir einen zusätzlichen Zeigerkopf, um zur Funktionsdefinition zu springen und zur Anweisung zurückzukehren. Um die Notwendigkeit solcher Zeigerköpfe zu beseitigen, verwenden wir Inline-Funktionen.

In einer Inline-Funktion wird ein Funktionsaufruf direkt durch einen tatsächlichen Programmcode ersetzt. Es wird nicht zu einem Block gesprungen, da alle Operationen innerhalb der Inline-Funktion ausgeführt werden.

Inline-Funktionen werden hauptsächlich für kleine Berechnungen verwendet. Sie sind nicht geeignet, wenn es sich um große Computer handelt.

Eine Inline-Funktion ähnelt der normalen Funktion, außer dass das Schlüsselwort inline vor dem Funktionsnamen steht. Inline-Funktionen werden mit der folgenden Syntax erstellt:

inline function_name (){//function definition}

Schreiben wir ein Programm zur Implementierung einer Inline-Funktion.

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

Ausgabe:

Addition: 30

Das obige Programm zeigt die Verwendung einer Inline-Funktion zum Hinzufügen von zwei Zahlen. Wie wir sehen können, haben wir die Addition auf zwei Zahlen innerhalb der Inline-Funktion nur zurückgegeben, ohne zusätzliche Zeilen zu schreiben. Während des Funktionsaufrufs haben wir gerade Werte übergeben, für die wir eine Addition durchführen müssen.

Zusammenfassung

• Eine Funktion ist ein Miniprogramm oder ein Unterprogramm.
• Funktionen werden verwendet, um das Programm zu modularisieren.
• Bibliothek und benutzerdefiniert sind zwei Arten von Funktionen.
• Eine Funktion besteht aus einer Deklaration, einem Funktionskörper und einem Funktionsaufrufteil.
• Funktionsdeklaration und Body sind obligatorisch.
• Ein Funktionsaufruf kann in einem Programm optional sein.
• C-Programm hat mindestens eine Funktion; es ist die Hauptfunktion ().
• Jede Funktion hat einen Namen, einen Datentyp des Rückgabewerts oder einen ungültigen Parameter.
• Jede Funktion muss in Ihrem C-Programm definiert und deklariert werden.
• Beachten Sie, dass gewöhnliche Variablen in einer C-Funktion zerstört werden, sobald wir den Funktionsaufruf beenden.
• Die an eine Funktion übergebenen Argumente werden nicht geändert, da sie als Wert keine Adresse übergeben werden.
• Der Variablenbereich wird als Sichtbarkeit von Variablen innerhalb eines Programms bezeichnet
• Es gibt globale und lokale Variablen in der C-Programmierung