Verschiedene Arten von Funktionen

Eine Funktion ist ein Code, um eine bestimmte Operation zu erreichen. Es hat einen Namen für seine Identifizierung. Hier sind wir nicht daran interessiert, die Funktion zu definieren. Hier diskutieren wir verschiedene Funktionen und ihre Anwendung.

Möglichkeiten, eine Funktion zu definieren

In der C -Sprache stehen vier Arten von Programmen zur Verfügung. Sie sind:

1. Nimmt nichts, gibt nichts zurück.

2. Nimmt etwas, gibt nichts zurück.

3. Nimmt nichts, gibt etwas zurück.

4. Nimmt etwas, gibt etwas zurück.

1. Nimmt nichts, gibt nichts zurück

Programmierbeispiel 1

#enthalten
void main ()

void add (void);
hinzufügen ();

void add ()

int a, b, c;
printf ("zwei Zahlen eingeben");
scanf (" %d %d", & a, & b);
c = a + b;
printf ("sum ist = %d", c);

Ausgang

Erläuterung

Wann immer wir ein Programm kompilieren möchten, muss der Compiler die Bedeutung jedes Wortes in einem Programm kennen, was bedeutet, dass es jede Funktion oder Variable im Programm deklarieren muss. Für diese Funktion ist eine Deklaration erforderlich. In der Funktionserklärung schreiben wir 3 Dinge

1. Rückgabetyp
2. Name von fm
3. Streit

Im Falle einer vordefinierten Funktion ist eine Deklaration in der Header -Datei geschrieben. Zum Beispiel: clrscr () - -> Deklaration erfolgt in Datei und Funktion werden in der Bibliotheksdatei definiert. Turbo C ++ 3.0 Compiler deklariert automatisch die benutzerdefinierte Funktion. Aber wir sollten eine Funktion deklarieren. Wir schreiben nur den Namen und Parameter, das in der Argument in der Aufruffunktion übergeben wurde.

2. Nimmt etwas, gibt nichts zurück

Programmierbeispiel 2

#enthalten
void add (int, int); // Funktionserklärung weltweit
void main ()

int x, y;
void add (int, int); // Funktionserklärung lokal
printf ("2 Zahlen eingeben");
scanf (" %d %d", & x, & y); // tatsächliche Argumente
add (x, y);

void add (int x, int y) // formelle Argumente

int c;
C = x+y;
printf ("sum ist %d", c);

Ausgang

Erläuterung

Wenn wir die beiden Werte von zwei Variablen hinzufügen möchten, die in der Main () deklariert sind und diese in einem anderen Funktionsnamen hinzufügen, addiert (), wir verwenden die Takes etwas Rendites Nichts -Methode. In diesem Fall wird der Wert von x und y an die Funktion hinzufügen, wenn add () in der Hauptfunktion aufgerufen wird. Dafür heißt es Call by Value.

Wenn wir einen Wert als Argument an eine Anruffunktion übergeben, werden diese Argumente als tatsächliche Argumentation bezeichnet.

Und in einer Funktionsdefinition in der Klammung einer Funktion deklarieren wir die Variable, die den Wert der von der Aufruffunktion übergebenen Variablen erhält, die als formales Argument bezeichnet wird.

Der Name des tatsächlichen Arguments und der formalen Argumentvariablen kann derselbe sein, da der Compiler in diesem Fall nicht verwirrt. Es weiß, dass Variable x, y, das in Main () und x deklariert wird, und x, y in add () deklariert werden.

Bei der Aufruffunktion bestehen wir nur den Wert von Variablen, die in Main deklariert werden (). Dafür schreiben wir add (x, y);

3. Nimmt nichts, gibt etwas zurück

Programmierbeispiel 3

#enthalten
int add (void);
void main ()

int s;
s = add ();
printf ("sum ist %d", s);

int add ()

int a, b, c;
printf ("zwei Zahlen eingeben");
scanf (" %d %d", & a, & b);
c = a+b;
Rückkehr C;

Ausgang

Erläuterung

Nimmt nichts an, wenn main () eine Funktion zum add () aufrufen, was bedeutet, dass es kein Argument erfordert. Es bedeutet, dass add () den Wert von Variablen vom Benutzer entgegennehmen und das Hinzufügen ausführen.

Etwas zurückgeben bedeutet add (); Geben Sie hier das zusätzliche Ergebnis an main () zurück, um die Schlüsselwortrendite zu verwenden. Wenn add () den Wert zurückgeben, muss dieser Wert in einer int -Datentypvariablen (n) aufbewahrt werden, die in Main () deklariert wird (). Denn hier ist der Rückgabetyp int int. Das ist der Mittelwert s = add () wird durch, s = Wert der Rückgabe ersetzt.

Dazu müssen wir hier in der Funktionsdefinition von add () den Rückgabetyp add () erwähnen, hier int int int. Im Falle einer Rückgabe geben wir nur einen Wert zurück. Also, kehren Sie zurück (a, b, c)-> ist falsch. Es bedeutet, dass es nur den Wert von C zurückgibt, da es zumindest innerhalb der Klammern geschrieben ist.

Wenn eine Funktion einen Wert zurückgibt, ist zu verstehen, dass die Kontrolle auch zur Aufruffunktion zurückkehrt.

Wenn wir nach der Rückgabeanweisung einen Code schreiben, hat dieser bestimmte Code keinen Einfluss auf das Programm, da sich die Steuerung auf die Aufruffunktion verlagert.

Jede Funktion kann nicht auf die von der andere Funktion deklarierte Variable zugreifen. Weil jede Variable, die in einer Funktion deklariert wird, als lokale Variable behandelt wird.

In Main () müssen wir den Wert von s anstelle von C drucken, da C die Variable ist, die in der add () deklariert wird, ().

4. Nimmt etwas, gibt etwas zurück

Programmierbeispiel 4

#enthalten
int add (int, int);
void main ()

int s, x, y;
printf ("2 Zahlen eingeben");
scanf (" %d %d", & x, & y);
s = add (x, y);
printf ("sum ist %d", s);

int add (int a, int b)

int c;
c = a+b;
Rückkehr C;

Ausgang

Erläuterung

Nimmt etwas zurück, das nichts programmiert ist, ist das gleiche wie die Nimms, die nichts zurückgeben; Der einzige Unterschied besteht.

Das bedeutet, dass der Benutzer den Wert von der vom Main verwendeten Tastatur () nimmt. Dieser Wert wird an den add () übergeben.

Es steht also auf dem Beispieltyp nach Wertpilz. Andernfalls entspricht die Rückgabeverfahren mit dem Nehmen nichts, gibt etwas Verfahren zurück.

Abschluss

Wenn wir über verschiedene Arten von Funktionen in C gelernt werden, sind wir zu dem Schluss gekommen, dass jede Art von Funktion das gleiche Ergebnis liefert. Aber jeder von ihnen hat einen anderen Mechanismus. Jeder von ihnen wird gemäß den Anforderungen des Programms benötigt. Wir müssen also jede Art von Funktion kennenlernen.