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

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 den Hauptteil einer Funktion 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, kann aber später Teil einer 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);

• Das return_data_type: ist der Datentyp der Wertfunktion, die an die aufrufende Anweisung zurückgegeben wird.
• Das Funktionsname: wird von Klammern gefolgt
• Argumente Namen mit ihren Datentypdeklarationen werden optional in Klammern gesetzt.

Wir betrachten das folgende Programm, das zeigt, wie man eine Kubusfunktion deklariert, um den Kubuswert einer ganzzahligen Variable 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, eine Funktion aufzurufen, wann immer dies in einem Programm erforderlich ist. Wann immer 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 betrachten das folgende Programm, das die Parameterübergabe als Wert 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 betrachten das folgende Programm, das den Wert der globalen Variable sowohl aus der Hauptfunktion 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 die Programmdetails:

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 beim erneuten Aufrufen der Funktion abgerufen werden. 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 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 Programmdetails:

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.

Das folgende Diagramm veranschaulicht den rekursiven Mechanismus, der darin besteht, die Funktion so lange selbst aufzurufen, bis der Basisfall eintritt oder der Abbruch erreicht ist.ping Die Bedingung ist erfüllt, und danach werden die vorherigen Werte erfasst:

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

Ausgang:

Addition: 30

Das obige Programm demonstriert die Verwendung einer Inline-Funktion zur Addition zweier Zahlen. Wie wir sehen, haben wir die Addition zweier Zahlen nur innerhalb der Inline-Funktion zurückgegeben, ohne zusätzliche Zeilen zu schreiben. Während des Funktionsaufrufs haben wir nur Werte übergeben, für die wir die 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