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

Was ist eine Funktion in C?

Funktion in der C-Programmierung ist ein wiederverwendbarer Codeblock, der ein Programm leichter verständlich und testbar macht und leicht modifiziert werden kann, 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 unterteilt, die als Funktionen bezeichnet werden

Wenn Sie ein großes Programm in verschiedene Funktionen unterteilen, wird es einfach, jede Funktion einzeln zu verwalten. Wenn im Programm ein Fehler auftritt, können Sie fehlerhafte Funktionen einfach untersuchen und nur diese Fehler beheben. Sie können Funktionen einfach aufrufen und verwenden, wann immer sie benötigt werden, was automatisch zu einer Zeit- und Platzersparnis führt.

In diesem Tutorial lernen Sie-

Bibliothek Vs. Benutzerdefinierte Funktionen
Funktionsdeklaration
Funktionsdefinition
Funktionsaufruf
Funktionsargumente
Variabler Geltungsbereich
Statische Variablen
Rekursive Funktionen
Inline-Funktionen

Bibliothek Vs. Benutzerdefinierte Funktionen

Jedes „C“-Programm hat mindestens eine Funktion, die Hauptfunktion, aber ein Programm kann beliebig viele Funktionen haben. Die Funktion main() in C ist ein Startpunkt eines Programms.

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

Bibliotheksfunktionen
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 ihn zusammen mit der richtigen Syntax verwenden. Printf, scanf sind Beispiele für eine Bibliotheksfunktion.

Dagegen ist eine benutzerdefinierte Funktion eine Art von Funktion, bei der wir einen Funktionskörper schreiben und die Funktion aufrufen müssen, wann immer 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 zum Beispiel

Funktionsdeklaration
Funktionsdefinition
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 einfach den Namen einer Funktion an, die wir in unserem Programm wie eine Variablendeklaration verwenden werden. Wir können eine Funktion nur verwenden, wenn sie in einem Programm deklariert ist. Eine Funktionsdeklaration wird auch „Funktions-Prototyp“ genannt .“

Die Funktionsdeklarationen (Prototyp genannt) werden normalerweise über der Hauptfunktion () 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.
Der Funktionsname :gefolgt von Klammern
Argumente Namen 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 Integer-Variablen zu berechnen

#include <stdio.h>
/*Function declaration*/
int add(int a,b);
/*End of Function declaration*/
int main() {

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

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

Funktionsdefinition

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

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

Funktionsaufruf

Ein Funktionsaufruf bedeutet, dass eine Funktion immer dann aufgerufen wird, wenn sie in einem Programm erforderlich ist. Immer wenn wir eine Funktion aufrufen, führt sie eine Operation aus, für die sie entworfen wurde. Ein Funktionsaufruf ist ein optionaler Teil eines Programms.

  result = add(4,5);

Hier ist der vollständige Code:

#include <stdio.h>
int add(int a, int b);	//function declaration
int main()
{
	int a=10,b=20;
	int c=add(10,20); 	//function call
	printf("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 durch den Funktionsaufruf zu erhalten. Sie werden nach Position abgeglichen; 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 ändert sich nicht.

Wir betrachten das folgende Programm, das als Wert übergebene 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 ist:

5 + 10 = 15

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

Variabler Geltungsbereich

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

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

#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

Wir besprechen die Programmdetails:

Wir deklarieren eine ganzzahlige globale Variable mit 1348 als Anfangswert.
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.
Wir geben die globale Variable innerhalb der Hauptfunktion aus.
Wir rufen die Testfunktion auf, um den globalen Variablenwert zu drucken.

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

Wenn Sie globale Variablen verwenden, verwenden Sie sie mit Vorsicht, da sie zu Fehlern führen können und sich überall in einem Programm ändern können. Sie sollten vor der Verwendung initialisiert werden.

Statische Variablen

Die statischen Variablen haben einen lokalen Gültigkeitsbereich. Sie werden jedoch beim Verlassen der Funktion nicht zerstört. Daher behält eine statische Variable ihren Wert für immer und es kann darauf zugegriffen werden, wenn die Funktion erneut eingegeben wird. Eine statische Variable wird bei der Deklaration initialisiert und benötigt das Präfix static.

Das folgende Programm verwendet eine statische 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 ++; }

Das Programm zeigt :

Hi number 1
Hi number 2
Hi number 3
Hi number 4
Hi 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 durch wiederholtes Berechnen von Fakt * (Fakt -1), bis Fakt gleich 1 ist.

Eine rekursive Funktion ist eine Funktion, die sich selbst aufruft und eine Beendigungsbedingung enthält, um die rekursiven Aufrufe zu beenden. Im Fall der Fakultätszahlberechnung ist die Ausgangsbedingung Tatsache gleich 1. Die Rekursion funktioniert durch „Stapeln“ von Aufrufen, bis die Ausgangsbedingung wahr ist.

Zum 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); /* exiting condition */
  else
    return (number * factorial(number - 1));
}

Das Programm zeigt Folgendes an:

 The factorial of 6 is 720

Hier besprechen wir Programmdetails:

Wir deklarieren unsere rekursive Fakultätsfunktion, die einen ganzzahligen Parameter nimmt und die Fakultät dieses Parameters zurückgibt. Diese Funktion ruft sich selbst auf und verringert die Zahl, bis der Ausgangs- oder Grundzustand erreicht ist. Wenn die Bedingung wahr ist, werden die zuvor generierten Werte miteinander multipliziert und der endgültige Fakultätswert zurückgegeben.
Wir deklarieren und initialisieren eine Integer-Variable mit dem Wert "6" und geben dann ihren Fakultätswert aus, indem wir unsere Fakultätsfunktion aufrufen.

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, und danach sammeln wir die vorherigen Werte:

Inline-Funktionen

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

Immer wenn eine Funktion aufgerufen wird, springt der Anweisungszeiger auf die Funktionsdefinition. Nach dem Ausführen einer Funktion fällt 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 solche Zeigerköpfe überflüssig zu machen, verwenden wir Inline-Funktionen.

Bei einer Inline-Funktion wird ein Funktionsaufruf direkt durch einen eigentlichen Programmcode ersetzt. Es springt zu keinem Block, 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 um große Rechenleistung geht.

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
}

Lassen Sie uns ein Programm schreiben, um eine Inline-Funktion zu implementieren.

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 demonstriert die Verwendung einer Inline-Funktion zur Addition von zwei Zahlen. Wie wir sehen können, haben wir die Addition zweier Zahlen innerhalb der Inline-Funktion nur zurückgegeben, ohne zusätzliche Zeilen zu schreiben. Während des Funktionsaufrufs haben wir gerade Werte übergeben, die wir addieren 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 Funktionsrumpf 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 eine Leerstelle, Parameter.
Jede Funktion muss in Ihrem C-Programm definiert und deklariert werden.
Denken Sie daran, 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 ohne Adresse übergeben wurden.
Variablenumfang wird als Sichtbarkeit von Variablen innerhalb eines Programms bezeichnet
In der C-Programmierung gibt es globale und lokale Variablen

C Dateien I/O:Erstellen, Öffnen, Lesen, Schreiben und Schließen einer Datei Pointer in C:Was ist Pointer in der C-Programmierung? Typen

C Sprache