Eine Funktion ist eine Reihe von Anweisungen, die Eingaben entgegennehmen, bestimmte Berechnungen durchführen und und produziert Output. Die Idee besteht darin, einige häufig oder wiederholt zu platzieren Aufgaben gemeinsam erledigt, um eine zu erstellen Funktion Damit wir diese Funktion aufrufen können, anstatt immer wieder denselben Code für verschiedene Eingaben zu schreiben.
Vereinfacht ausgedrückt ist eine Funktion ein Codeblock, der nur ausgeführt wird, wenn er aufgerufen wird.
Syntax:
Syntax der Funktion
Beispiel:
C++
// C++ Program to demonstrate working of a function> #include> using> namespace> std;> // Following function that takes two parameters 'x' and 'y'> // as input and returns max of two input numbers> int> max(>int> x,>int> y)> {> >if> (x>y)> >return> x;> >else> >return> y;> }> // main function that doesn't receive any parameter and> // returns integer> int> main()> {> >int> a = 10, b = 20;> >// Calling above function to find max of 'a' and 'b'> >int> m = max(a, b);> >cout <<>'m is '> << m;> >return> 0;> }> |
>
Designmuster in Java
>Ausgabe
m is 20>
Zeitkomplexität: O(1)
Raumkomplexität: O(1)
Warum brauchen wir Funktionen?
- Funktionen helfen uns dabei Reduzierung der Code-Redundanz . Wenn Funktionalität an mehreren Stellen in der Software ausgeführt wird, erstellen wir eine Funktion und rufen sie überall auf, anstatt immer wieder denselben Code zu schreiben. Dies hilft auch bei der Wartung, da wir Änderungen nur an einer Stelle vornehmen müssen, wenn wir in Zukunft Änderungen an der Funktionalität vornehmen.
- Funktionen erzeugen Code modular . Stellen Sie sich eine große Datei mit vielen Codezeilen vor. Es wird wirklich einfach, den Code zu lesen und zu verwenden, wenn der Code in Funktionen unterteilt wird.
- Funktionen bieten Abstraktion . Beispielsweise können wir Bibliotheksfunktionen nutzen, ohne uns um deren interne Arbeit kümmern zu müssen.
Funktionsdeklaration
Eine Funktionsdeklaration teilt dem Compiler die Anzahl der Parameter, die Datentypen der Parameter und den Rückgabetyp der Funktion mit. Das Schreiben von Parameternamen in die Funktionsdeklaration ist optional, es ist jedoch notwendig, sie in die Definition einzufügen. Nachfolgend finden Sie ein Beispiel für Funktionsdeklarationen. (Parameternamen sind in den folgenden Deklarationen nicht vorhanden)
Funktionsdeklaration
Beispiel:
C++
// C++ Program to show function that takes> // two integers as parameters and returns> // an integer> int> max(>int>,>int>);> // A function that takes an int> // pointer and an int variable> // as parameters and returns> // a pointer of type int> int>* swap(>int>*,>int>);> // A function that takes> // a char as parameter and> // returns a reference variable> char>* call(>char> b);> // A function that takes a> // char and an int as parameters> // and returns an integer> int> fun(>char>,>int>);> |
>
>
Arten von Funktionen
Funktionstypen in C++
Benutzerdefinierte Funktion
Benutzerdefinierte Funktionen sind benutzer-/kundendefinierte Codeblöcke, die speziell angepasst wurden, um die Komplexität großer Programme zu reduzieren. Sie sind auch allgemein bekannt als maßgeschneiderte Funktionen die nur dazu entwickelt wurden, die Bedingung zu erfüllen, in der der Benutzer mit Problemen konfrontiert ist, und gleichzeitig die Komplexität des gesamten Programms zu reduzieren.
Bibliotheksfunktion
Es werden auch Bibliotheksfunktionen aufgerufen Integrierte Funktionen . Diese Funktionen sind Teil eines bereits definierten Compilerpakets und bestehen aus einer speziellen Funktion mit besonderen und unterschiedlichen Bedeutungen. Integrierte Funktionen verschaffen uns einen Vorteil, da wir sie direkt verwenden können, ohne sie zu definieren, während wir bei benutzerdefinierten Funktionen eine Funktion deklarieren und definieren müssen, bevor wir sie verwenden können.
Zum Beispiel: sqrt(), setw(), strcat() usw.
Parameterübergabe an Funktionen
Die an die Funktion übergebenen Parameter werden aufgerufen tatsächliche Parameter . Im folgenden Programm sind beispielsweise 5 und 10 tatsächliche Parameter.
Die von der Funktion empfangenen Parameter werden aufgerufen formale Parameter . Im obigen Programm sind x und y beispielsweise formale Parameter.
Formaler Parameter und Aktualparameter
Es gibt zwei gängige Methoden zum Übergeben von Parametern:
- Wert übergeben: Bei dieser Parameterübergabemethode werden Werte tatsächlicher Parameter in die formalen Parameter der Funktion kopiert. Die tatsächlichen und formalen Parameter werden an unterschiedlichen Speicherorten gespeichert, sodass sich Änderungen an den Funktionen nicht in den tatsächlichen Parametern des Aufrufers widerspiegeln.
- Referenz übergeben: Sowohl tatsächliche als auch formale Parameter beziehen sich auf dieselben Speicherorte, sodass alle innerhalb der Funktion vorgenommenen Änderungen in den tatsächlichen Parametern des Aufrufers widergespiegelt werden.
Funktionsdefinition
Wert übergeben wird verwendet, wenn der Wert von x nicht mit der Funktion fun() geändert wird.
C++
// C++ Program to demonstrate function definition> #include> using> namespace> std;> void> fun(>int> x)> {> >// definition of> >// function> >x = 30;> }> int> main()> {> >int> x = 20;> >fun(x);> >cout <<>'x = '> << x;> >return> 0;> }> |
>
>Ausgabe
x = 20>
Zeitkomplexität: O(1)
Raumkomplexität: O(1)
Funktionen mit Zeigern
Die Funktion fun() erwartet einen Zeiger ptr auf eine Ganzzahl (oder eine Adresse einer Ganzzahl). Es ändert den Wert an der Adresse ptr. Der Dereferenzierungsoperator * wird verwendet, um auf den Wert an einer Adresse zuzugreifen. In der Anweisung „*ptr = 30“ wird der Wert an der Adresse ptr auf 30 geändert. Der Adressoperator & wird verwendet, um die Adresse einer Variablen eines beliebigen Datentyps abzurufen. In der Funktionsaufrufanweisung „fun(&x)“ wird die Adresse von x übergeben, sodass x anhand seiner Adresse geändert werden kann.
C++
// C++ Program to demonstrate working of> // function using pointers> #include> using> namespace> std;> void> fun(>int>* ptr) { *ptr = 30; }> int> main()> {> >int> x = 20;> >fun(&x);> >cout <<>'x = '> << x;> >return> 0;> }> |
>
>Ausgabe
x = 30>
Zeitkomplexität: O(1)
Raumkomplexität: O(1)
Unterschied zwischen Call-by-Value und Call-by-Reference in C++
| Rufen Sie nach Wert auf | Rufen Sie per Referenz an |
|---|---|
| Eine Kopie des Werts wird an die Funktion übergeben | Der Funktion wird eine Wertadresse übergeben |
| Änderungen innerhalb der Funktion sind nicht der Fall auf andere Funktionen reflektiert | Innerhalb der Funktion vorgenommene Änderungen werden widergespiegelt auch außerhalb der Funktion |
| Sachliche und formale Argumente werden erstellt unterschiedlicher Speicherort | Sachliche und formale Argumente werden erstellt gleichen Speicherort. |
Wichtige Hinweise zu Funktionen in C++
1. Die meisten C++-Programme verfügen über eine Funktion namens main(), die vom Betriebssystem aufgerufen wird, wenn ein Benutzer das Programm ausführt.
2. Jede Funktion hat einen Rückgabetyp. Wenn eine Funktion keinen Wert zurückgibt, wird void als Rückgabetyp verwendet. Wenn der Rückgabetyp der Funktion außerdem void ist, können wir die return-Anweisung trotzdem im Hauptteil der Funktionsdefinition verwenden, indem wir keine Konstante, Variable usw. angeben, sondern nur die „return;“-Anweisung erwähnen, die dies tun würde symbolisieren die Beendigung der Funktion wie unten gezeigt:
C++
void> function name(>int> a)> {> >.......>// Function Body> >return>;>// Function execution would get terminated> }> |
>
>
3. Um eine Funktion zu deklarieren, die nur ohne Parameter aufgerufen werden kann, sollten wir verwenden Spaß machen (nichtig) . Nebenbei bemerkt: In C++ bedeutet eine leere Liste, dass eine Funktion nur ohne Parameter aufgerufen werden kann. In C++ sind void fun() und void fun(void) gleich.
Hauptfunktion
Die Hauptfunktion ist eine Sonderfunktion. Jedes C++-Programm muss eine Funktion namens main enthalten. Es dient als Einstiegspunkt für das Programm. Der Computer beginnt mit der Ausführung des Codes vom Anfang der Hauptfunktion an.
Arten von Hauptfunktionen
1. Ohne Parameter:
CPP
// Without Parameters> int> main() { ...>return> 0; }> |
>
>
2. Mit Parametern:
CPP
// With Parameters> int> main(>int> argc,>char>*>const> argv[]) { ...>return> 0; }> |
>
Addierer voll
>
Der Grund für die Parameteroption für die Hauptfunktion besteht darin, Eingaben über die Befehlszeile zu ermöglichen. Wenn Sie die Hauptfunktion mit Parametern verwenden, speichert sie jede Gruppe von Zeichen (durch ein Leerzeichen getrennt) nach dem Programmnamen als Elemente in einem Array mit dem Namen argv .
Da die Hauptfunktion den Rückgabetyp hat int , muss der Programmierer immer eine Return-Anweisung im Code haben. Die zurückgegebene Zahl wird verwendet, um das aufrufende Programm über das Ergebnis der Programmausführung zu informieren. Die Rückgabe von 0 signalisiert, dass keine Probleme aufgetreten sind.
C++-Rekursion
Wenn eine Funktion innerhalb derselben Funktion aufgerufen wird, spricht man in C++ von Rekursion. Die Funktion, die dieselbe Funktion aufruft, wird als rekursive Funktion bezeichnet.
Eine Funktion, die sich selbst aufruft und nach dem Funktionsaufruf keine Aufgabe ausführt, wird als Tail-Rekursion bezeichnet. Bei der Tail-Rekursion rufen wir im Allgemeinen dieselbe Funktion mit der Return-Anweisung auf.
Syntax:
C++
recursionfunction()> {> >recursionfunction();>// calling self function> }> |
>
>
Um mehr zu erfahren, sehen Sie Dieser Artikel .
C++ übergibt ein Array an eine Funktion
In C++ können wir zur Wiederverwendung der Array-Logik eine Funktion erstellen. Um in C++ ein Array an eine Funktion zu übergeben, müssen wir nur den Array-Namen angeben.
function_name(array_name[]); //passing array to function>
Beispiel: Gibt die Mindestanzahl im angegebenen Array aus.
C++
#include> using> namespace> std;> void> printMin(>int> arr[5]);> int> main()> {> >int> ar[5] = { 30, 10, 20, 40, 50 };> >printMin(ar);>// passing array to function> }> void> printMin(>int> arr[5])> {> >int> min = arr[0];> >for> (>int> i = 0; i <5; i++) {> >if> (min>arr[i]) {> >min = arr[i];> >}> >}> >cout <<>'Minimum element is: '> << min <<>'
'>;> }> // Code submitted by Susobhan Akhuli> |
>
>Ausgabe
Minimum element is: 10>
Zeitkomplexität: O(n) wobei n die Größe des Arrays ist
Raumkomplexität: O(n) wobei n die Größe des Arrays ist.
C++-Überladung (Funktion)
Wenn wir zwei oder mehr Mitglieder mit demselben Namen, aber unterschiedlicher Anzahl oder Art der Parameter erstellen, spricht man von einer C++-Überladung. In C++ können wir Folgendes überladen:
- Methoden,
- Konstrukteure und
- indizierte Eigenschaften
Arten der Überladung in C++ sind:
- Funktionsüberlastung
- Überlastung des Bedieners
Überladen von C++-Funktionen
Unter Funktionsüberladung versteht man den Prozess, bei dem zwei oder mehr Funktionen mit demselben Namen, aber unterschiedlichen Parametern vorhanden sind. Bei der Funktionsüberladung wird die Funktion neu definiert, indem entweder unterschiedliche Typen oder eine andere Anzahl von Argumenten verwendet werden. Nur durch diese Unterschiede kann ein Compiler zwischen den Funktionen unterscheiden.
Der Vorteil der Funktionsüberladung besteht darin, dass sie die Lesbarkeit des Programms erhöht, da Sie für dieselbe Aktion keine unterschiedlichen Namen verwenden müssen.
Beispiel: Anzahl der Argumente der Methode add() ändern
C++
// program of function overloading when number of arguments> // vary> #include> using> namespace> std;> class> Cal {> public>:> >static> int> add(>int> a,>int> b) {>return> a + b; }> >static> int> add(>int> a,>int> b,>int> c)> >{> >return> a + b + c;> >}> };> int> main(>void>)> {> >Cal C;>// class object declaration.> >cout << C.add(10, 20) << endl;> >cout << C.add(12, 20, 23);> >return> 0;> }> // Code Submitted By Susobhan Akhuli> |
>
>Ausgabe
30 55>
Zeitkomplexität: O(1)
Raumkomplexität: O(1)
Beispiel: Wenn die Art der Argumente variiert.
C++
// Program of function overloading with different types of> // arguments.> #include> using> namespace> std;> int> mul(>int>,>int>);> float> mul(>float>,>int>);> int> mul(>int> a,>int> b) {>return> a * b; }> float> mul(>double> x,>int> y) {>return> x * y; }> int> main()> {> >int> r1 = mul(6, 7);> >float> r2 = mul(0.2, 3);> >cout <<>'r1 is : '> << r1 << endl;> >cout <<>'r2 is : '> << r2 << endl;> >return> 0;> }> // Code Submitted By Susobhan Akhuli> |
>
>Ausgabe
r1 is : 42 r2 is : 0.6>
Zeitkomplexität: O(1)
Raumkomplexität: O(1)
Funktionsüberladung und Mehrdeutigkeit
Wenn der Compiler nicht entscheiden kann, welche Funktion unter den überladenen Funktionen aufgerufen werden soll, spricht man von dieser Situation Funktionsüberladung, Mehrdeutigkeit.
Wenn der Compiler den Mehrdeutigkeitsfehler anzeigt, führt der Compiler das Programm nicht aus.
Ursachen für Unklarheiten:
- Typkonvertierung.
- Funktion mit Standardargumenten.
- Funktion mit Pass-by-Reference.
Typkonvertierung:-
C++
#include> using> namespace> std;> void> fun(>int>);> void> fun(>float>);> void> fun(>int> i) { cout <<>'Value of i is : '> << i << endl; }> void> fun(>float> j)> {> >cout <<>'Value of j is : '> << j << endl;> }> int> main()> {> >fun(12);> >fun(1.2);> >return> 0;> }> // Code Submitted By Susobhan Akhuli> |
>
>
Das obige Beispiel zeigt einen Fehler Der Aufruf von überladenem „fun(double)“ ist mehrdeutig . Der fun(10) ruft die erste Funktion auf. Der fun(1.2) ruft gemäß unserer Vorhersage die zweite Funktion auf. Dies bezieht sich jedoch nicht auf eine Funktion wie in C++, alle Gleitkommakonstanten werden als Double und nicht als Float behandelt. Wenn wir float durch double ersetzen, funktioniert das Programm. Daher handelt es sich hier um eine Typkonvertierung von float nach double.
Funktion mit Standardargumenten:-
C++
#include> using> namespace> std;> void> fun(>int>);> void> fun(>int>,>int>);> void> fun(>int> i) { cout <<>'Value of i is : '> << i << endl; }> void> fun(>int> a,>int> b = 9)> {> >cout <<>'Value of a is : '> << a << endl;> >cout <<>'Value of b is : '> << b << endl;> }> int> main()> {> >fun(12);> >return> 0;> }> // Code Submitted By Susobhan Akhuli> |
>
15 von 100,00
>
Das obige Beispiel zeigt einen Fehler Der Aufruf von überladenem „fun(int)“ ist mehrdeutig . fun(int a, int b=9) kann auf zwei Arten aufgerufen werden: Erstens durch Aufrufen der Funktion mit einem Argument, d. h. fun(12), und auf eine andere Art und Weise durch Aufrufen der Funktion mit zwei Argumenten, d. h. fun(4). ,5). Die Funktion fun(int i) wird mit einem Argument aufgerufen. Daher konnte der Compiler nicht zwischen fun(int i) und fun(int a,int b=9) wählen.
Funktion mit Pass-By-Referenz:-
C++
#include> using> namespace> std;> void> fun(>int>);> void> fun(>int>&);> int> main()> {> >int> a = 10;> >fun(a);>// error, which fun()?> >return> 0;> }> void> fun(>int> x) { cout <<>'Value of x is : '> << x << endl; }> void> fun(>int>& b)> {> >cout <<>'Value of b is : '> << b << endl;> }> // Code Submitted By Susobhan Akhuli> |
>
>
Das obige Beispiel zeigt einen Fehler Der Aufruf von überladenem „fun(int&)“ ist mehrdeutig . Die erste Funktion akzeptiert ein ganzzahliges Argument und die zweite Funktion verwendet einen Referenzparameter als Argument. In diesem Fall weiß der Compiler nicht, welche Funktion der Benutzer benötigt, da es keinen syntaktischen Unterschied zwischen fun(int) und fun(int &) gibt.
Freundefunktion
- Eine Friend-Funktion ist eine spezielle Funktion in C++, die, obwohl sie keine Mitgliedsfunktion einer Klasse ist, das Recht hat, auf private und geschützte Daten einer Klasse zuzugreifen.
- Eine Friend-Funktion ist eine Nichtmitgliedsfunktion oder eine gewöhnliche Funktion einer Klasse, die mithilfe des Schlüsselworts Friend innerhalb der Klasse deklariert wird. Durch die Deklaration einer Funktion als Freund werden der Funktion alle Zugriffsberechtigungen erteilt.
- Das Schlüsselwort „friend“ wird nur in der Funktionsdeklaration, nicht jedoch in der Funktionsdefinition platziert.
- Beim Aufruf der Friend-Funktion wird weder der Name des Objekts noch der Punktoperator verwendet. Es kann jedoch das Objekt als Argument akzeptieren, auf dessen Wert es zugreifen möchte.
- Eine Friend-Funktion kann in jedem Abschnitt der Klasse deklariert werden, d. h. öffentlich, privat oder geschützt.
Deklaration der Friend-Funktion in C++
Syntax:
class { friend (argument/s); };> Beispiel_1: Finden Sie die größte von zwei Zahlen mithilfe der Friend-Funktion
C++
#include> using> namespace> std;> class> Largest {> >int> a, b, m;> public>:> >void> set_data();> >friend> void> find_max(Largest);> };> void> Largest::set_data()> {> >cout <<>'Enter the first number : '>;> >cin>> a;> >cout <<>'
Enter the second number : '>;> >cin>> b;> }> void> find_max(Largest t)> {> >if> (t.a>t.b)> >t.m = t.a;> >else> >t.m = t.b;> >cout <<>'
Largest number is '> << t.m;> }> int> main()> {> >Largest l;> >l.set_data();> >find_max(l);> >return> 0;> }> |
>
>
Ausgabe
Enter the first number : 789 Enter the second number : 982 Largest number is 982>