Funktionen in der C-Programmierung mit Beispielen: Rekursiv und 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 geändert werden kann, ohne das aufrufende Programm zu ändern. Funktionen unterteilen 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 aufgerufen werden

Was ist eine Funktion in C?

Wenn Sie ein großes Programm in verschiedene Funktionen unterteilen, ist 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 ganz einfach aufrufen und nutzen, wann immer sie benötigt werden, was automatisch zu einer Zeit- und Platzersparnis führt.

Bibliothek vs. Benutzerdefinierte Funktionen

Jedes „C“-Programm hat mindestens eine Funktion, die die Hauptfunktion ist, aber ein Programm kann beliebig viele Funktionen haben. Die Funktion main() in C ist ein Ausgangspunkt 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 lediglich den Namen einer Funktion eingeben und ihn zusammen mit der richtigen Syntax verwenden. Printf, scanf sind Beispiele für eine Bibliotheksfunktion.

Eine benutzerdefinierte Funktion hingegen ist ein Funktionstyp, bei dem wir einen Funktionskörper schreiben und die Funktion immer dann aufrufen müssen, wenn die Funktion eine Operation in unserem Programm ausführen soll.

Eine benutzerdefinierte Funktion in C wird immer vom Benutzer geschrieben, aber later Es kann 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:

  1. Funktionsdeklaration
  2. Funktionsdefinition
  3. Funktionsaufruf

Funktionserklärung

Unter Funktionsdeklaration versteht man das Schreiben eines Programmnamens. Es ist ein obligatorischer Bestandteil für die Verwendung von Funktionen im Code. In einer Funktionsdeklaration geben wir einfach den Namen einer Funktion an, die wir in unserem Programm verwenden werden, wie bei einer Variablendeklaration. Wir können eine Funktion nur verwenden, wenn sie in einem Programm deklariert ist. Eine Funktionsdeklaration wird auch „Funktion“ genannt Prototyp"

Die Funktionsdeklarationen (Prototyp genannt) erfolgen normalerweise über der Funktion main() 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: wird von Klammern gefolgt
  • Argumente Namen mit ihren Datentypdeklarationen werden optional in Klammern gesetzt.

Wir berücksichtigen Folgendeswing Programm, das zeigt, wie man eine Cube-Funktion deklariert, um den Cube-Wert einer ganzzahligen Variablen zu berechnen

#include <stdio.h>
/*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.

Die Funktionsdeklaration „output_message“ gibt beispielsweise an, dass die Funktion keinen Wert zurückgibt: void output_message();

Funktionsdefinition

Unter Funktionsdefinition versteht man lediglich das Schreiben des Hauptteils einer Funktion. Ein Funktionskörper besteht aus Anweisungen, die eine bestimmte Aufgabe ausführen. Ein Funktionskörper besteht aus einer einzelnen Anweisung oder einem Block von Anweisungen. 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, dass eine Funktion immer dann aufgerufen wird, wenn sie in einem Programm benötigt wird. Immer wenn wir eine Funktion aufrufen, führt sie eine Operation aus, für die sie entwickelt 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;
}

Ausgang:

Addition:30

Funktionsargumente

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

Standardmäßig Die Argumente werden als Wert übergeben Dabei wird der aufgerufenen Funktion eine Kopie der Daten übergeben. Die tatsächlich übergebene Variable ändert sich nicht.

Wir berücksichtigen Folgendeswing 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 Add-Funktion übergeben wurden, nicht geändert wurden, da nur ihr Wert an den Parameter x übergeben wurde.

Variablenbereich

Unter Variablenbereich versteht man 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 außerhalb der Funktion nicht referenziert werden. Variablen, die außerhalb aller Funktionen deklariert werden, sind jedoch global und vom gesamten Programm aus zugänglich. Mit a deklarierte Konstanten #define am Anfang eines Programms sind vom gesamten Programm aus zugänglich. Wir berücksichtigen Folgendeswing Programm, das den Wert der globalen Variablen sowohl aus der Haupt- als auch aus 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 das Programm details:

Variablenbereich

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

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

Wenn Sie verwenden, globale Variablen, verwenden Sie sie mit Vorsicht, da sie zu Fehlern führen können und sie sich überall im 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 kann bei erneuter Eingabe der Funktion aufgerufen werden. Eine statische Variable wird bei der Deklaration initialisiert und benötigt das Präfix static.

Die folgendenwing 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 abzuschließen. Im Fall der Fakultätszahlberechnung ist die Ausgangsbedingung gleich 1. Bei der Rekursion werden Aufrufe „gestapelt“, bis die Ausgangsbedingung wahr ist.

Beispielsweise:

#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:

 The factorial of 6 is 720

Hier besprechen wir das Programm details:

Rekursive Funktionen

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

Betrachten Sie Folgendeswing 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 die vorherigen Werte zu sammeln:

Rekursive Funktionen

Inline-Funktionen

Eine Funktion wird in der C-Programmierung zum Speichern der am häufigsten verwendeten Anweisungen verwendet. Es dient der Modularisierung des Programms.

Bei jedem Aufruf einer Funktion springt der Anweisungszeiger zur Funktionsdefinition. Nach der Ausführung einer Funktion fällt der Anweisungszeiger auf die Anweisung zurück, von der aus er zur Funktionsdefinition gesprungen ist.

Immer wenn wir Funktionen verwenden, benötigen wir ein Extra Zeiger head, 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 tatsächlichen Programmcode ersetzt. Es wird nicht zu einem Block gesprungen, da alle Operationen innerhalb der Inline-Funktion ausgeführt werden.

Inline-Funktionen werden meist für kleine Berechnungen verwendet. Sie sind nicht geeignet, wenn große Rechenkapazitäten erforderlich sind.

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

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();
}

Ausgang:

Addition: 30

Das obige Programm demonstriert die Verwendung einer Inline-Funktion zur Addition zweier Zahlen. Wie wir sehen können, haben wir die Addition auf zwei Zahlen nur innerhalb der Inline-Funktion zurückgegeben, ohne zusätzliche Zeilen zu schreiben. Beim Funktionsaufruf haben wir gerade Werte übergeben, für die wir eine Addition durchführen müssen.

Zusammenfassung

  • Eine Funktion ist ein Miniprogramm oder ein Unterprogramm.
  • Zur Modularisierung des Programms werden Funktionen verwendet.
  • 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, einen Rückgabewert oder einen Leerwert sowie Parameter.
  • Jede Funktion muss in Ihrem C-Programm definiert und deklariert werden.
  • Denken Sie daran, dass gewöhnlich Variablen in einer C-Funktion werden zerstört, sobald wir den Funktionsaufruf beenden.
  • Die an eine Funktion übergebenen Argumente werden nicht geändert, da sie als Wert und nicht als Adresse übergeben werden.
  • Der Variablenbereich wird als Sichtbarkeit von Variablen innerhalb eines Programms bezeichnet
  • Es gibt globale und lokale Variablen C-Programmierung