Menü

Funktionen in C ++ mit Typen und Beispielen

  • Haupt
  • Andere
  • Funktionen in C ++ mit Typen und Beispielen

functions c with types examples

Versuchen Sie Unser Instrument, Um Probleme Zu Beseitigen

Arten von Funktionen in C ++ zusammen mit ihren Verwendungen.

In unseren früheren Tutorials haben wir bisher die verschiedenen Konzepte in C ++ wie Variablen, Speicherklassen, Operatoren, Arrays, Strings usw. gesehen.

In diesem Tutorial werden wir das Konzept der Funktionen diskutieren. Funktionen werden auch als Methoden, Unterprogramme oder Prozeduren bezeichnet.

=> Lesen Sie hier die umfangreiche C ++ - Schulungsserie.

FUNKTIONEN IN C ++

Was du lernen wirst:

Wie definieren wir eine Funktion?

Eine Funktion ist eine Reihe von Anweisungen, die zur Ausführung einer bestimmten Aufgabe zusammengestellt werden. Es können Anweisungen sein, die einige wiederholte Aufgaben ausführen, oder Anweisungen, die einige spezielle Aufgaben wie Drucken usw. ausführen.

Eine Verwendung von Funktionen besteht darin, den Code zu vereinfachen, indem er in kleinere Einheiten unterteilt wird, die als Funktionen bezeichnet werden. Eine weitere Idee hinter der Verwendung von Funktionen ist, dass wir nicht immer wieder denselben Code schreiben müssen. Wir müssen nur eine Funktion schreiben und sie dann nach Bedarf aufrufen, ohne immer wieder dieselben Anweisungen schreiben zu müssen.

Arten von Funktionen in C ++

In C ++ gibt es zwei Arten von Funktionen, wie unten gezeigt.

Arten von Funktionen in C ++

Eingebaute Funktionen

Integrierte Funktionen werden auch als Bibliotheksfunktionen bezeichnet. Dies sind die Funktionen, die von C ++ bereitgestellt werden, und wir müssen sie nicht selbst schreiben. Wir können diese Funktionen direkt in unserem Code verwenden.

Diese Funktionen werden in die Header-Dateien von C ++ gestellt. Zum Beispiel ,, sind die Header, die eingebaute mathematische Funktionen bzw. Zeichenfolgenfunktionen haben.

Sehen wir uns ein Beispiel für die Verwendung integrierter Funktionen in einem Programm an.

#include #include using namespace std; int main() { string name; cout << 'Enter the input string:'; getline (std::cin, name); cout << 'String entered: ' << name << '! '; int size = name.size(); cout<<'Size of string : '<

Ausgabe:

Geben Sie die Eingabezeichenfolge ein: Software Testing Help
Zeichenfolge eingegeben: Software Testing Help!
Größe der Zeichenfolge: 21

Hier verwenden wir die Header und. Die Datentypen und andere Eingabe- / Ausgabefunktionen werden in der Bibliothek definiert. String-Funktionen wie getline, size sind Teil des Headers.

Benutzerdefinierte Funktionen

Mit C ++ können Benutzer auch ihre eigenen Funktionen definieren. Dies sind die benutzerdefinierten Funktionen. Wir können die Funktionen an einer beliebigen Stelle im Programm definieren und diese Funktionen dann von einem beliebigen Teil des Codes aus aufrufen. Genau wie Variablen sollte sie vor der Verwendung deklariert werden. Funktionen müssen auch deklariert werden, bevor sie aufgerufen werden.

Lassen Sie uns benutzerdefinierte Funktionen im Detail diskutieren.

Die allgemeine Syntax für benutzerdefinierte Funktionen (oder einfach Funktionen) lautet wie folgt:

return_type functionName(param1,param2,….param3) { Function body; }

Wie oben gezeigt, hat jede Funktion:

  • Rückgabetyp: Dies ist der Wert, den die Funktionen nach Ausführung einer bestimmten Aufgabe an die aufrufende Funktion zurückgeben.
  • Funktionsname : Kennung zur Benennung einer Funktion.
  • Parameterliste: In der obigen Syntax mit param1, param2,… paramn bezeichnet. Dies sind die Argumente, die bei einem Funktionsaufruf an die Funktion übergeben werden. Die Parameterliste ist optional, d. H. Wir können Funktionen haben, die keine Parameter haben.
  • Funktionskörper: Eine Gruppe von Anweisungen, die eine bestimmte Aufgabe ausführen.

Wie bereits erwähnt, müssen wir eine Funktion deklarieren, bevor wir sie verwenden können.

Funktionserklärung

Eine Funktionsdeklaration informiert den Compiler über den Rückgabetyp der Funktion, die Anzahl der von der Funktion verwendeten Parameter und ihre Datentypen. Die Deklaration ist optional, wenn die Namen der Parameter in die Funktion aufgenommen werden. Die Funktionsdeklaration wird auch als Funktionsprototyp bezeichnet.

Wir haben einige Beispiele für die Funktionsdeklaration unten als Referenz angegeben.

int sum(int, int);

Die obige Deklaration enthält eine Funktion 'sum', die zwei Ganzzahlen als Parameter verwendet und einen Ganzzahlwert zurückgibt.

void swap(int, int);

Dies bedeutet, dass die Swap-Funktion zwei Parameter vom Typ int verwendet und keinen Wert zurückgibt. Daher ist der Rückgabetyp ungültig.

void display();

Die Funktionsanzeige akzeptiert keine Parameter und gibt auch keinen Typ zurück.

Funktionsdefinition

Eine Funktionsdefinition enthält alles, was eine Funktionsdeklaration enthält, und zusätzlich den in Klammern ({}) eingeschlossenen Funktionskörper.

Darüber hinaus sollte es auch benannte Parameter haben. Beim Aufruf der Funktion geht die Steuerung des Programms an die Funktionsdefinition über, damit der Funktionscode ausgeführt werden kann. Wenn die Ausführung der Funktion beendet ist, kehrt die Steuerung zu dem Punkt zurück, an dem die Funktion aufgerufen wurde.

Für die obige Erklärung der Swap-Funktion lautet die Definition wie folgt:

void swap(int a, int b){ b = a + b; a = b - a; b = b - a; }

Beachten Sie, dass Deklaration und Definition einer Funktion zusammenpassen können. Wenn wir eine Funktion definieren, bevor wir darauf verweisen, ist keine separate Deklaration erforderlich.

Nehmen wir ein vollständiges Programmierbeispiel, um eine Funktion zu demonstrieren.

#include using namespace std; void swap(int a, int b) { //here a and b are formal parameters b = a + b; a = b - a; b = b - a; cout<<' After swapping: '; cout<<'a = '< Eine Funktion aufrufen

Wenn wir eine Funktion in unserem Programm haben, müssen wir diese Funktion je nach Anforderung aufrufen oder aufrufen. Nur wenn die Funktion aufgerufen oder aufgerufen wird, führt die Funktion ihre Anweisungen aus, um die gewünschten Ergebnisse zu erzielen.

Die Funktion kann von überall im Programm aufgerufen werden. Es kann von der Hauptfunktion oder von jeder anderen Funktion aufgerufen werden, wenn das Programm mehr als eine Funktion verwendet. Die Funktion, die eine andere Funktion aufruft, wird als 'Aufruffunktion' bezeichnet.

Im obigen Beispiel für das Austauschen von Zahlen wird die Swap-Funktion in der Hauptfunktion aufgerufen. Daher wird die Hauptfunktion zur aufrufenden Funktion.

Formale und tatsächliche Parameter

Wir haben bereits gesehen, dass wir Parameter für die Funktionen haben können. Die Funktionsparameter werden in der Funktionsdefinition als Parameterliste bereitgestellt, die dem Funktionsnamen folgt. Wenn die Funktion aufgerufen wird, müssen wir die tatsächlichen Werte dieser Parameter übergeben, damit die Funktion unter Verwendung dieser tatsächlichen Werte ihre Aufgabe ausführen kann.

Die in der Funktionsdefinition definierten Parameter werden aufgerufen Formale Parameter . Die Parameter im Funktionsaufruf, die die tatsächlichen Werte sind, werden aufgerufen Aktuelle Parameter.

Im obigen Beispiel für den Austausch von Zahlen haben wir die Kommentare für formale und tatsächliche Parameter geschrieben. In der aufrufenden Funktion, d. H. Main, wird der Wert von zwei ganzen Zahlen gelesen und an die Swap-Funktion übergeben. Dies sind die tatsächlichen Parameter.

Wir können die Definitionen dieser Parameter in der ersten Zeile der Funktionsdefinition sehen. Dies sind die formalen Parameter.

Beachten Sie, dass die Art der formalen und tatsächlichen Argumente übereinstimmen sollte. Die Reihenfolge der formalen und tatsächlichen Parameter sollte ebenfalls übereinstimmen.

Rückgabewerte

Sobald die Funktion ihre beabsichtigte Aufgabe ausgeführt hat, sollte sie das Ergebnis an die aufrufende Funktion zurückgeben. Dazu benötigen wir den Rückgabetyp der Funktion. Die Funktion kann einen einzelnen Wert an die aufrufende Funktion zurückgeben. Der Rückgabetyp der Funktion wird zusammen mit dem Funktionsprototyp deklariert.

Nehmen wir ein Beispiel für das Hinzufügen von zwei Zahlen, um die Rückgabetypen zu demonstrieren.

#include using namespace std; int sum(int a, int b){ return (a+b); } int main() { int a, b, result; cout<>a>>b; result = sum(a,b); cout<<' Sum of the two numbers : '<

Ausgabe:

Geben Sie die beiden hinzuzufügenden Zahlen ein: 11 11

Summe der beiden Zahlen: 22

Im obigen Beispiel haben wir eine Funktionssumme, die zwei ganzzahlige Parameter akzeptiert und einen ganzzahligen Typ zurückgibt. In der Hauptfunktion lesen wir zwei Ganzzahlen von der Konsoleneingabe und übergeben sie an die Summenfunktion. Da der Rückgabetyp eine Ganzzahl ist, haben wir eine Ergebnisvariable auf der LHS und RHS ist ein Funktionsaufruf.

Wenn eine Funktion ausgeführt wird, wird der von der Funktionssumme zurückgegebene Ausdruck (a + b) der Ergebnisvariablen zugewiesen. Dies zeigt, wie der Rückgabewert der Funktion verwendet wird.

Leere Funktionen

Wir haben gesehen, dass für die allgemeine Funktionssyntax ein Rückgabetyp definiert werden muss. Aber wenn wir eine solche Funktion haben, die keinen Wert zurückgibt, was geben wir in diesem Fall als Rückgabetyp an? Die Antwort ist, dass wir den wertlosen Typ 'void' verwenden, um anzuzeigen, dass die Funktion keinen Wert zurückgibt.

In einem solchen Fall heißt die Funktion 'void function' und ihr Prototyp ist wie folgt

void functionName (param1, param2,… .param 3);

Hinweis : Es wird als bewährte Methode angesehen, eine Erklärung „return“ aufzunehmen. am Ende der Leerfunktion zur Klarheit.

Parameter an Funktionen übergeben

Wir haben bereits das Konzept der tatsächlichen und formalen Parameter gesehen. Wir wissen auch, dass tatsächliche Parameter Werte an eine Funktion übergeben, die von den Formatparametern empfangen wird. Dies wird als Übergabe von Parametern bezeichnet.

In C ++ haben wir bestimmte Möglichkeiten, Parameter zu übergeben, wie unten erläutert.

Wert übergeben

In dem zuvor besprochenen Programm zum Austauschen von zwei Ganzzahlen haben wir gesehen, dass wir nur die Ganzzahlen 'a' und 'b' in main gelesen und an die Swap-Funktion übergeben haben. Dies ist die Pass-by-Value-Technik.

Bei der Pass-by-Value-Technik der Parameterübergabe werden die Kopien der Werte der tatsächlichen Parameter an die formalen Parameter übergeben. Aus diesem Grund werden die tatsächlichen und formalen Parameter an verschiedenen Speicherorten gespeichert. Änderungen an formalen Parametern innerhalb der Funktion werden daher nicht außerhalb der Funktion wiedergegeben.

Wir können dies besser verstehen, wenn wir noch einmal den Austausch zweier Zahlen besuchen.

#include using namespace std; void swap(int a, int b) { //here a and b are formal parameters b = a + b; a = b - a; b = b - a; cout<<' After swapping inside Swap: '; cout<<'a = '< Referenz übergeben

Referenzübergabe ist eine weitere Technik, mit der C ++ Parameter an Funktionen übergibt. Bei dieser Technik übergeben wir anstelle von Kopien der tatsächlichen Parameter Verweise auf die tatsächlichen Parameter.

Hinweis: Referenzen sind nichts anderes als Aliase von Variablen oder in einfachen Worten ein anderer Name, der einer Variablen gegeben wird. Daher teilen sich eine Variable und ihre Referenz denselben Speicherort. In unserem nachfolgenden Tutorial werden wir ausführliche Referenzen erfahren.

In der Pass-by-Referenztechnik verwenden wir diese Referenzen der tatsächlichen Parameter. Infolgedessen werden die an formalen Parametern in der Funktion vorgenommenen Änderungen auf die aufrufende Funktion zurückgeführt.

Wir ändern unsere Swap-Funktion, damit unsere Leser das Konzept besser verstehen.

#include #include using namespace std; void swap(int &a, int &b){ int temp = a; a = b; b = temp; } int main() { int a,b; cout<>a>>b; cout<<'a = '<

Daher spiegeln sich die Änderungen an den formalen Parametern in der Swap-Funktion in der Hauptfunktion wider und wir erhalten die Swap-Werte.

Fahren Sie am Zeiger vorbei

In C ++ können wir Parameter auch mithilfe von Zeigervariablen an die Funktion übergeben. Die Pass-by-Pointer-Technik liefert die gleichen Ergebnisse wie die Pass-by-Reference. Dies bedeutet, dass sich sowohl formale als auch tatsächliche Parameter die gleichen Speicherorte teilen und die in der Funktion vorgenommenen Änderungen in der aufrufenden Funktion wiedergegeben werden.

Der einzige Unterschied besteht darin, dass wir in einer Referenzübergabe Referenzen oder Aliase von Parametern behandeln, während wir in einer Übergabe-Zeigertechnik Zeigervariablen verwenden, um die Parameter zu übergeben.

Zeigervariablen unterscheiden sich von den Referenzen, in denen Zeigervariablen auf eine bestimmte Variable verweisen, und im Gegensatz zu Referenzen können wir die Variable ändern, auf die sie verweist. Wir werden die Details des Zeigers in unseren nachfolgenden Tutorials untersuchen.

Wir präsentieren erneut das Vertauschen zweier Ganzzahlen, um die Pass by Pointer-Technik zu demonstrieren.

#include #include using namespace std; void swap(int *a, int *b) { int temp = *a; *a = *b; *b = temp; } int main() { int a,b; cout<>a>>b; cout<<'a = '< Standardparameter

In C ++ können wir Standardwerte für Funktionsparameter bereitstellen. In diesem Fall geben wir beim Aufrufen der Funktion keine Parameter an. Stattdessen übernimmt die Funktion die Standardparameter, die im Prototyp angegeben sind.

Das folgende Beispiel zeigt die Verwendung von Standardparametern.

#include #include using namespace std; int mathoperation(int a, int b = 3, int c = 2){ return ((a*b)/c); } int main() { int a,b,c; cout<>a>>b>>c; cout<

Ausgabe:

Geben Sie Werte für a, b und c ein: 10 4 6

Aufruf zur mathematischen Operation mit 1 Argument: 15
Aufruf zur mathematischen Operation mit 2 Argumenten: 20
Aufruf zur mathematischen Operation mit 3 Argumenten: 6

Wie im Codebeispiel gezeigt, haben wir eine Funktion 'mathoperation', die drei Parameter übernimmt, aus denen wir Standardwerte für zwei Parameter bereitgestellt haben. Dann rufen wir diese Funktion in der Hauptfunktion dreimal mit einer anderen Argumentliste auf.

Der erste Aufruf erfolgt mit nur einem Argument. In diesem Fall haben die beiden anderen Argumente Standardwerte. Der nächste Aufruf erfolgt mit zwei Argumenten. In diesem Fall hat das dritte Argument einen Standardwert. Der dritte Aufruf besteht aus drei Argumenten. In diesem Fall werden Standardwerte ignoriert, da wir alle drei Argumente angegeben haben.

Beachten Sie, dass wir bei der Bereitstellung von Standardparametern immer vom Parameter ganz rechts ausgehen. Außerdem können wir keinen Parameter dazwischen überspringen und einen Standardwert für den nächsten Parameter angeben.

Kommen wir nun zu einigen speziellen funktionsbezogenen Konzepten, die aus Sicht eines Programmierers wichtig sind.

Const-Parameter

Wir können auch konstante Parameter an Funktionen übergeben, indem wir das Schlüsselwort 'const' verwenden. Wenn ein Parameter oder eine Referenz const ist, kann er innerhalb der Funktion nicht geändert werden.

Beachten Sie, dass wir einen const-Parameter nicht an einen nicht-const-formalen Parameter übergeben können. Wir können jedoch const- und non-const-Parameter an einen const-Formalparameter übergeben.

In ähnlicher Weise können wir auch den Rückgabetyp const haben. Auch in diesem Fall kann der Rückgabetyp nicht geändert werden.

Sehen wir uns ein Codebeispiel an, das const-Referenzen verwendet.

#include #include using namespace std; int addition(const int &a, const int &b){ return (a+b); } int main() { int a,b; cout<>a>>b; cout<<'a = '<

Ausgabe:

Geben Sie die beiden auszutauschenden Nummern ein: 22 33
a = 2 b = 33
Ergebnis der Zugabe: 55

Im obigen Programm haben wir konstante formale Parameter. Beachten Sie, dass die tatsächlichen Parameter gewöhnliche nicht konstante Variablen sind, die wir erfolgreich übergeben haben. Da formale Parameter const sind, können wir sie nicht innerhalb der Funktion ändern. Also führen wir einfach die Additionsoperation aus und geben den Wert zurück.

Wenn wir versuchen, die Werte von a oder b innerhalb der Funktion zu ändern, gibt der Compiler einen Fehler aus.

Inline-Funktionen

Wir wissen, dass zum Ausführen eines Funktionsaufrufs intern ein Compiler den Status des Programms auf einem Stapel speichert, bevor die Steuerung an die Funktion übergeben wird.

Wenn die Funktion zurückkehrt, muss der Compiler den Programmstatus zurückrufen und an der Stelle fortfahren, an der er verlassen wurde. Dies ist mit einem Overhead verbunden. Daher gibt es in C ++ immer dann, wenn wir eine Funktion haben, die aus wenigen Anweisungen besteht, eine Funktion, mit der sie inline erweitert werden kann. Dies geschieht, indem eine Funktion inline geschaltet wird.

Inline-Funktionen sind also die Funktionen, die zur Laufzeit erweitert werden, wodurch der Aufwand für den Aufruf der Funktion und die Durchführung der Stapeländerungen gespart wird. Aber selbst wenn wir eine Funktion als Inline-Funktion erstellen, garantiert der Compiler nicht, dass sie zur Laufzeit erweitert wird. Mit anderen Worten, es hängt vollständig vom Compiler ab, ob die Funktion inline geschaltet wird oder nicht.

Einige Compiler erkennen kleinere Funktionen und erweitern sie inline, auch wenn sie nicht inline deklariert sind.

Es folgt ein Beispiel für eine Inline-Funktion.

inline int addition(const int &a,const int &b){ return (a+b); }

Wie oben gezeigt, wird der Funktionsdefinition ein Schlüsselwort 'inline' vorangestellt, um eine Funktion inline zu machen.

Verwenden von Strukturen in Funktionen

Wir können Strukturvariablen als Parameter übergeben, um auf ähnliche Weise zu funktionieren, wie wir gewöhnliche Variablen als Parameter übergeben.

Dies wird im folgenden Beispiel gezeigt.

#include #include using namespace std; struct PersonInfo { int age; char name(50); double salary; }; void printStructInfo(PersonInfo p) { cout<<'PersonInfo Structure:'; cout<<' Age:'< p.age; cout <> p.salary; printStructInfo(p); }

Ausgabe:

Name eingeben: Vedang
Alter eingeben: 22
Gehalt eingeben: 45000.00
PersonInfo-Struktur:
Alter: 22
Name: Vedang
Gehalt: 45000

Strukturen in Funktionen verwenden - Ausgabe

Youtube zu MP4 Konverter für Mac

Wie im obigen Programm gezeigt, übergeben wir eine Struktur, die auf ähnliche Weise wie andere Variablen funktioniert. Wir lesen Werte für Strukturelemente aus der Standardeingabe und übergeben dann eine Struktur an eine Funktion, die die Struktur anzeigt.

Fazit

Hier ging es um die Grundlagen der Funktionen in C ++.

In unseren nächsten Tutorials werden wir mehr über die statischen Funktionen in C ++ erfahren.

=> Überprüfen Sie hier die komplette C ++ FREE-Schulungsserie.

Literatur-Empfehlungen

^