Rufen Sie nach Wert an und rufen Sie durch Referenz in C -Sprache an
Funktion ist ein sehr wichtiges Konzept in der C -Sprache. Funktion ist ein Stück Code, das uns hilft, bestimmte Aktionen auszuführen. Basierend auf seiner Definition kann die Funktion in vier Typen unterteilt werden.
Dies basiert auf der Funktion, die Eingabe und Rückgabebereich aufnimmt und die Ausgabe zurückgeht.
- Keine eingeben und keine ausgeben.
- Geben Sie einen Wert ein und geben Sie keine aus.
- Keine eingeben und einen gewissen Wert ausgeben.
- Geben Sie einen gewissen Wert ein und geben Sie einen gewissen Wert aus.
Im heutigen Thema werden wir Anrufe nach Wert und Ruf durch Referenz diskutieren. Diese Themen basieren vollständig auf der Klassifizierung der Funktion.
Programmierbeispiel 1:
In diesem Programm -Beispiel werden wir den Anlaufmechanismus nach Wert sehen.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 | #enthalten int add (int, int); // Funktionserklärungsprototyp. int main () int s, x, y; printf ("2 Zahlen eingeben"); scanf (" %d %d", & x, & y); s = add (x, y); // Funktionsaufruf. printf ("sum ist %d", s); Rückkehr 0; int add (int a, int b) // Definition der Funktion und das Bestehen des Wertes durch Funktion. int c; c = a + b; Rückkehr C; |
Ausgang:
Erläuterung:
Dieses Programmierbeispiel ist das ideale Beispiel für den Aufruf nach Wert. Es ist das Beispiel von Nimmt etwas und gibt etwas zurück.
Geben Sie einen gewissen Wert und Ausgang ein, das kein Programm gleich ist als die Eingabe keine und geben einen gewissen Wert aus. Der einzige Unterschied besteht darin, dass es von Natur aus etwas nimmt, so dass der Wert von zwei Zahlen in der Anruffunktion übergeben werden muss. Sie heißen tatsächliche Argumente.
Oder der Benutzer nimmt den Wert von der Tastatur, die von Main () Funktion verwendet wird. Der Wert wird dann an die Funktion add () übergeben. Diese Werte werden genannt formelle Argumente.
Es ist also eine Art von Art von nach Wert genannt Beispiel. Andernfalls entspricht das Rückgaberang der Rückgänge, wie das nichts nimmt, etwas Verfahren zurückgibt.
Programmierbeispiel 2:
Hier sehen wir ein weiteres Beispiel für die Aufruf -By -Value -Methode, indem wir etwas anwenden und nichts verfahren.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 | #enthalten void add (int, int); // Funktionserklärung weltweit int 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); Rückkehr 0; 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 Hauptstufe deklariert werden (). Fügen Sie dies in einem anderen Funktionsnamen hinzu add (). Dann nimmt wir etwas zurück, die keine Methode zurückgibt. In diesem Fall wird in der Hauptfunktion der Wert von x an die Funktion hinzufügen, wenn add () aufgerufen wird. Denn dies kann als als benannt werden Rufen Sie nach Wert an.
Wenn wir den Wert als Argument an eine Aufruffunktion übergeben, werden diese Argumente als tatsächliche Argumente bezeichnet.
Per Definition, innerhalb der Klammern einer Funktion, wenn wir die Variable deklarieren, die den Wert der Variablen erhält, der von der Aufruffunktion übergeben wird.
Der Name der Variablen des tatsächlichen Arguments und des formalen Arguments kann gleich sein, da Compiler diese Variable weiß x, y werden in main () Funktion deklariert und x, y Deklared in add () sind unterschiedliche Variablen.
Bei der Aufruffunktion bestehen wir nur den Wert von Variablen, der in Main () deklariert wird (). Dafür schreiben wir add (x, y);
Programmierbeispiel 3:
Hier sehen wir ein Beispiel für die Anrufe, indem wir die Adresse anwenden und etwas verantwortlich zurückgeben.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 | #enthalten int add (int *, int *); // Funktionsprototypdeklaration weltweit int main () int s, x, y; printf ("zwei Zahlen eingeben:"); scanf (" %d %d", & x, & y); s = add (& x, & y); // die Adresse von Variablen übergeben. printf ("Die Summe ist: %d \ n", s); Rückkehr 0; int add (int *a, int *b) int c; c = *a + *b; Rückgabe (c); |
Ausgang:
Erläuterung:
Dies ist ein Beispiel für Anruf durch Bezugnahme. Manchmal tritt in unserem Programm eine Situation auf, wenn wir den Wert der Variablen durch Funktion nicht bestehen können. Wir müssen die Adresse dieser Variablen übergeben, um darauf zuzugreifen. Es heißt Call per Referenz.
Hier übergeben wir die Adresse von Variable A, Variable B In der Funktion hinzufügen, um die Werte von zu summieren Variable A, Variable B.
Programmierbeispiel 4:
Hier werden wir ein weiteres Beispiel für die Anrufanwendung sehen, indem Sie angewendet werden und etwas verankert.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 | #enthalten Int Swap (int *, int *); int main () int p = 56; int q = 22; printf ("Vor dem Austausch des Wertes von Ganzzahl p: %d \ n", p); printf ("Vor dem Austausch des Wertes der Ganzzahl q: %d \ n", q); Swap (& p, & q); // die Funktion aufrufen. printf ("Nach dem Austausch des Werts von Ganzzahl p: %d \ n", p); printf ("Nach dem Austausch des Wertes der Ganzzahl q: %d \ n", q); Rückkehr 0; Int Swap (int *x, int *y) // die Adresse von Variablen übergeben. int t; / * Temporäre Variable, um den Wert der 1. Variablen zu speichern */ t = *x; *x = *y; *y = t; |
Ausgang:
Erläuterung:
Dies ist ein Beispiel für Anruf durch Bezugnahme. Manchmal tritt in unserem Programm eine Situation auf, wenn wir den Wert der Variablen durch Funktion nicht bestehen können. Wir müssen die Adresse dieser Variablen übergeben, um darauf zuzugreifen. Es heißt Call per Referenz.
Hier übergeben wir die Adresse von Variable A, Variable B In der SWAP () -Funktion, um die Werte von zu tauschen Variable A, Variable B. Infolgedessen die Werte von a, b werden durch den Anruf durch Referenz versetzt.