A Benutzerdefinierte Funktion ist eine Art Funktion in der Sprache C, die vom Benutzer selbst definiert wird, um eine bestimmte Aufgabe auszuführen. Es verleiht unserem Programm Code-Wiederverwendbarkeit und Modularität. Benutzerdefinierte Funktionen unterscheiden sich von integrierten Funktionen dadurch, dass ihre Funktionsweise vom Benutzer festgelegt wird und für ihre Verwendung keine Header-Datei erforderlich ist.
In diesem Artikel erfahren wir mehr darüber benutzerdefinierte Funktion, Funktionsprototyp, Funktionsdefinition, Funktionsaufruf und verschiedene Möglichkeiten, wie wir Parameter an eine Funktion übergeben können.
Wie verwende ich benutzerdefinierte Funktionen in C?
Um eine benutzerdefinierte Funktion verwenden zu können, müssen wir zunächst die verschiedenen Teile ihrer Syntax verstehen. Die benutzerdefinierte Funktion in C kann in drei Teile unterteilt werden:
- Funktionsprototyp
- Funktionsdefinition
- Funktionsaufruf
C-Funktionsprototyp
Ein Funktionsprototyp wird auch als Funktionsdeklaration bezeichnet, die die angibt Funktionsname, Funktionsparameter, Und Rückgabetyp . Der Funktionsprototyp enthält nicht den Hauptteil der Funktion. Es dient im Wesentlichen dazu, den Compiler über die Existenz der benutzerdefinierten Funktion zu informieren, die im späteren Teil des Programms verwendet werden kann.
Syntax
return_type function_name (type1 arg1 , type2 arg2 , ... typeN argN );>
Wir können den Namen der Argumente im Funktionsprototyp auch überspringen. Also,
return_type function_name (type1 , type2 , ... typeN);>
C-Funktionsdefinition
Sobald die Funktion aufgerufen wurde, enthält die Funktionsdefinition die tatsächlichen Anweisungen, die ausgeführt werden. Alle Anweisungen der Funktionsdefinition sind darin eingeschlossen { } Zahnspange.
Syntax
return_type function_name (type1 arg1 , type2 arg2 .... typeN argN ) { // actual statements to be executed // return value if any }> Notiz: Wenn der Funktionsaufruf nach der Funktionsdefinition vorhanden ist, können wir den Teil des Funktionsprototyps überspringen und die Funktion direkt definieren.
C-Funktionsaufruf
Um die Kontrolle an eine benutzerdefinierte Funktion zu übergeben, müssen wir sie aufrufen. Funktionen werden mit ihrem Namen aufgerufen, gefolgt von runden Klammern. Ihre Argumente werden in den Klammern übergeben.
Syntax
function_name(arg1, arg2, ... argN);>
Beispiel einer benutzerdefinierten Funktion
Das folgende C-Programm veranschaulicht, wie Sie benutzerdefinierte Funktionen in unserem Programm verwenden.
C
// C Program to illustrate the use of user-defined function> #include> // Function prototype> int> sum(>int>,>int>);> // Function definition> int> sum(>int> x,>int> y)> {> >int> sum;> >sum = x + y;> >return> x + y;> }> // Driver code> int> main()> {> >int> x = 10, y = 11;> >// Function call> >int> result = sum(x, y);> >printf>(>'Sum of %d and %d = %d '>, x, y, result);> >return> 0;> }> |
>
>Ausgabe
Sum of 10 and 11 = 21>
Komponenten der Funktionsdefinition
Die Funktionsdefinition besteht aus drei Komponenten:
- Funktionsparameter
- Funktionskörper
- Rückgabewert
1. Funktionsparameter
Funktionsparameter (auch als Argumente bezeichnet) sind die Werte, die vom Aufrufer an die aufgerufene Funktion übergeben werden. Wir können der Funktion keine oder beliebig viele Funktionsparameter übergeben.
Wir müssen den Funktionsnamen und seinen Typ in der Funktionsdefinition definieren und können im Funktionsaufruf nur die gleiche Anzahl und Art von Parametern übergeben.
Beispiel
int foo ( int a, int b) ;>
Hier, A Und B sind Funktionsparameter.
Notiz: Die Sprache C bietet eine Methode, mit der wir eine variable Anzahl von Argumenten an die Funktion übergeben können. Solche Funktionen werden als variadische Funktion bezeichnet.
2. Funktionskörper
Der Funktionskörper ist der Satz von Anweisungen, die in {}-Klammern eingeschlossen sind. Dies sind die Anweisungen, die beim Aufruf der Funktion ausgeführt werden.
Beispiel
int foo (int a, int b) { int sum = a + b; return sum; }> Hier sind die Aussagen zwischen { Und } ist Funktionskörper.
3. Rückgabewert
Der Rückgabewert ist der Wert, den die Funktion an ihren Aufrufer zurückgibt. Eine Funktion kann nur einen einzelnen Wert zurückgeben und ist optional. Soll kein Wert zurückgegeben werden, wird der Rückgabetyp als void definiert.
Der Schlüsselwort zurückgeben wird verwendet, um den Wert einer Funktion zurückzugeben.
Java-Ende für Schleife
Syntax
return ( expression );>
Beispiel
int foo (int a, int b) { return a + b; }> Notiz: Wir können Zeiger oder Strukturen verwenden, um mehrere Werte von einer Funktion in C zurückzugeben.
Übergabe von Parametern an benutzerdefinierte Funktionen
Wir können Parameter mit zwei Methoden an eine Funktion in C übergeben:
wie man einen String in eine Ganzzahl umwandelt
- Aufruf nach Wert
- Aufruf per Referenz
1. Rufen Sie nach Wert auf
Beim Aufruf nach Wert wird eine Kopie des Werts an die Funktion übergeben und an der Funktion vorgenommene Änderungen werden nicht auf die Werte zurückgespiegelt. Tatsächliche und formale Argumente werden an unterschiedlichen Speicherorten erstellt.
Beispiel
C
// C program to show use of> // call by value> #include> void> swap(>int> a,>int> b)> {> >int> temp = a;> >a = b;> >b = temp;> }> // Driver code> int> main()> {> >int> x = 10, y = 20;> >printf>(>'Values of x and y before swap are: %d, %d
'>, x,> >y);> >swap(x, y);> >printf>(>'Values of x and y after swap are: %d, %d'>, x,> >y);> >return> 0;> }> |
>
>Ausgabe
Values of x and y before swap are: 10, 20 Values of x and y after swap are: 10, 20>
Notiz: Werte werden im Call-by-Value nicht geändert, da sie nicht als Referenz übergeben werden.
2. Rufen Sie per Referenz an
Bei einem Aufruf per Referenz wird die Adresse des Arguments an die Funktion übergeben und an der Funktion vorgenommene Änderungen werden auf die Werte zurückgespiegelt. Wir benutzen das Hinweise vom erforderlichen Typ, um die Adresse in der Funktion zu erhalten.
Beispiel
C
// C program to implement> // Call by Reference> #include> void> swap(>int>* a,>int>* b)> {> >int> temp = *a;> >*a = *b;> >*b = temp;> }> // Driver code> int> main()> {> >int> x = 10, y = 20;> >printf>(>'Values of x and y before swap are: %d, %d
'>, x,> >y);> >swap(&x, &y);> >printf>(>'Values of x and y after swap are: %d, %d'>, x,> >y);> >return> 0;> }> |
>
>Ausgabe
Values of x and y before swap are: 10, 20 Values of x and y after swap are: 20, 10>
Weitere Einzelheiten finden Sie in diesem Artikel – Unterschied zwischen Call by Value und Call by Reference
Vorteile benutzerdefinierter Funktionen
Die Vorteile der Verwendung von Funktionen im Programm sind folgende:
- Durch den Einsatz von Funktionen kann man die Duplizierung von Code in den Programmen vermeiden. Code lässt sich schneller schreiben und ist dadurch besser lesbar.
- Code kann mithilfe von Funktionen geteilt und erobert werden. Dieser Prozess wird als Divide and Conquer bezeichnet. Es ist schwierig, große Codemengen innerhalb der Hauptfunktion zu schreiben sowie zu testen und zu debuggen. Unsere eine Aufgabe lässt sich durch den Einsatz von Funktionen in mehrere kleinere Teilaufgaben aufteilen und so die Gesamtkomplexität reduzieren.
- Wenn man beispielsweise pow, sqrt usw. in C verwendet, ohne zu wissen, wie es implementiert ist, kann man Implementierungsdetails mit Funktionen verbergen.
- Mit wenigen oder gar keinen Änderungen können in einem Programm entwickelte Funktionen in einem anderen verwendet werden, wodurch die Entwicklungszeit verkürzt wird.