C/C++ Schritt-für-Schritt - Seite 6

06. Schritt-für-Schritt C/C++ — C Programmierung - Funktionen

Funktionen

| | 1. Numerische Funktionen

2. Zeichenfolgenfunktionen
3. Zeichen-Testfunktionen | | | V. Benutzerdefinierte Funktionen | | | 1. Einfache Funktionen
4. Funktion mit Argumenten
5. Funktion mit Rückgaben
6. Funktion mit Rekursion | | | VI. Zeiger und Funktionen | | | 1. Parameterübergabe durch Referenz
7. Aufruf durch Wert
8. Aufruf durch Referenz | | | VII. Lokal vs Global | | | VIII. Speicherklassenspezifizierer | | | Automatische Speicherklasse
   Register-Speicherklasse
   Statische Speicherklasse
   Externe Speicherklasse |

I. Einführung

Hier ist ein Programm, um die Adresse einer Person zweimal auszugeben, das sowohl mit Funktionen als auch ohne Funktionen geschrieben ist. Es wird den Vorteil von Funktionen demonstrieren.

| | #include
int main()
{
printf(“\nName der Person”);
printf(“\nStraße, Wohnung//Hausnummer “);
printf(“\nPLZ, Stadt”);
printf(“\nLand”);

printf(“\nName der Person”);
printf(“\nStraße, Wohnung//Hausnummer “);
printf(“\nPLZ, Stadt”);
printf(“\nLand”);

return 0;
} | #include
void address()
{
printf(“\nName der Person”);
printf(“\nStraße, Wohnung//Hausnummer “);
printf(“\nPLZ, Stadt”);
printf(“\nLand”);
}

int main()
{
address();
address();

return 0;
} |

II. Funktionsdefinition

Ein Block von Anweisungen, der in der Lage ist, Werte als Argumente zu akzeptieren und Ergebnisse an das aufrufende Programm zurückzugeben. Eine Funktion ist also ein eigenständiger Block von Anweisungen, der eine bestimmte Aufgabe ausführt.

III. Arten von Funktionen

| | - Eingebaute Funktionen/ Bibliotheksfunktionen/ Vorgegebene Funktionen

• Benutzerdefinierte Funktionen |

IV. Bibliotheksfunktionen

Bibliotheksfunktionen werden vom Hersteller der Software entworfen und werden auf die Festplatte geladen, wann immer die Software geladen wird.

Die folgenden Funktionen sind Beispiele für Bibliotheksfunktionen.

1. Numerische Funktionen

2. Zeichenfolgenfunktionen

3. Zeichen-Testfunktionen

Es gibt eine riesige Bibliothek von Funktionen, ich habe dir nur einen kleinen Teil davon gegeben. Für mehr Bibliotheksfunktionen siehe das Hilfemanual.

V. Benutzerdefinierte Funktionen

Die Programme, die du bereits gesehen hast, führen Arbeitsteilungen durch. Wenn du gets, puts oder strcmp aufrufst, musst du dir keine Gedanken darüber machen, wie das Innere dieser Funktionen funktioniert.

Diese und etwa 400 andere Funktionen sind bereits für dich in der Turbo C-Bibliothek definiert und kompiliert. Um sie zu verwenden, musst du nur die entsprechende Header-Datei in dein Programm einfügen, “Die Laufzeitbibliothek”, in den Bibliotheksverweis, um sicherzustellen, dass du verstehst, wie man die Funktionen aufruft und welchen Wert (falls vorhanden) sie zurückgibt.

Aber du musst deine eigenen Funktionen schreiben. Um dies zu tun, musst du deinen Code in diskrete Abschnitte (Funktionen) unterteilen, die jeweils eine einzelne, verständliche Aufgabe für deine Funktionen ausführen, die du im gesamten Programm auf die gleiche Weise aufrufen kannst, wie du C-Bibliotheksfunktionen aufrufst.

Schritte zur Implementierung einer Funktion

| | 1. Deklaration

2. Funktionsaufruf
3. Definition |

| | • Jede Funktion muss zu Beginn des Programms deklariert werden.
• Die Funktionsdefinition enthält den tatsächlichen Code zur Ausführung der Aufgabe.
• Wenn eine Funktion zu Beginn des Programms definiert ist, ist keine Funktionsdeklaration erforderlich. |

Ein Beispiel für eine Funktion zur Demonstration der Implementierung

| | / 32_egfun.c /
#include

void address(); / Deklaration /

int main()
{
address(); / Funktionsaufruf /
address(); / Funktionsaufruf /

return 0;
}

void address() / Definition /
{
printf(“\nName der Person”);
printf(“\nStraße, Wohnung//Hausnummer “);
printf(“\nPLZ, Stadt”);
printf(“\nLand”);
} |

Benutzerdefinierte Funktionen können in 4 Typen unterteilt werden, basierend darauf, wie wir sie aufrufen.

| | 1. Einfache Funktionen

2. Funktion mit Argumenten
3. Funktion mit Rückgaben
4. Funktion mit Rekursion |

1. Einfache Funktionen

Führt nur eine spezifische Aufgabe aus, benötigt keine Argumente und auch keine Rückgabewerte.

Beispiel einer einfachen Funktion

| | / 33_line.c /
#include
void line(); / Deklaration /
int main()
{
line(); / Funktionsaufruf /
return 0;
}
void line() / Definition /
{
int i;
for(i =1;i<80; i++)
putch(‘*’);
} |

2. Funktion mit Argumenten

Eine Funktion, die Argumente akzeptiert, wird als Funktion mit Argumenten bezeichnet.

Beispiel.

| | / 34_argu.c /
void line(char ch, int n)
int main()
{
line(“-“, 50);
line(“*”, 8);
return 0;
}
void line(char ch, int n)
{
int i;
for( i = 1; i<=n; i++ )
putch(ch);
} |

3. Funktion mit Rückgabewerten

Eine Funktion, die Werte an das aufrufende Programm zurückgeben kann, wird als Funktion mit Rückgabewerten bezeichnet.

Beispiel.

| | / 35_retu.c /
int abs(int n);
int main()
{
int res;
printf(“%d”, abs(-35))

res = abs(-34); / Funktionsaufruf/

printf(“%d”, res);
return 0;
}
void abs(int n)
{
if( n < 0 )
n = n * -1;
return n;
} |

4. Funktion mit Rekursion

Wenn eine Anweisung im Körper einer Funktion die gleiche Funktion aufruft, wird dies als ‘Rekursion’ bezeichnet. Manchmal als ‘zirkuläre Definition’ bezeichnet, ist Rekursion somit der Prozess, etwas in Bezug auf sich selbst zu definieren.

Beispiele für rekursive Funktionen

| | / Das folgende Programm demonstriert den Funktionsaufruf von sich selbst /
int main( )
{
printf(“\nHallo”);
main( ); / Eine Funktion, die sich selbst aufrufen kann /
return 0;
}
Lass dieses Programm nicht laufen, es ist immer noch eine Erklärung, daher ist das Programm logisch nicht gültig.

Der gleiche Output kann mit einer anderen Funktion erreicht werden: void disp( );

int main( )
{
disp( );
return 0;
}

void disp( )
{
printf(“\nHallo”);
disp( );
} |

Das Programm muss an einem bestimmten Punkt enden, daher liegt der Schlüssel zur Rekursion in einer sanften Unterbrechung, die mit einer Bedingung definiert werden kann.
Überprüfe das folgende Beispiel:

| | / 36_recursion.c /
int i = 1; / Deklaration einer globalen Variablen /
void disp( );
int main( )
{
disp( );
return 0;
}

void disp( )
{
printf(“\nHallo %d “, i);
i ++;
if( i < 10 ) / wenn der i-Wert kleiner als 10 ist, rufe die Funktion erneut auf /
disp( );
} |

| | Programm zur Berechnung der Fakultät der gegebenen Zahl:
/ 37_fact.c /
int factorial(int x);
void main
{
int a, fact;
printf(“\nGib eine beliebige Zahl ein “); scanf(“%d”, &a);
fact = factorial(a);
printf(“\nFakultät ist = %d”, fact);
}
int factorial(int x)
{
int f = 1, i;
for( i = x; i>=1; i–)
f = f i;
return f;
} | Um die Fakultät einer gegebenen Zahl mit Rekursion zu finden
/ 38_fact.c /
int rec_fact(int x);
int main( )
{
int a, fact;
printf(“\nGib eine beliebige Zahl ein “); canf(“%d”, &a);
fact = rec_fact(a);
printf(“\nFakultätswert ist = %d”, fact);
return 0;
}
int f = 1;
int rec_fact(int x)
{
if( x > 1)
f = x rec_fact(x-1);
return f;
} |

VI. Zeiger und Funktionen

| | Parameterübergabe durch Referenz
Aufruf durch Wert
Aufruf durch Referenz |

1. Parameterübergabe durch Referenz

Der Zeiger kann in der Funktionsdeklaration verwendet werden und dies macht eine komplexe Funktion leicht darzustellen und zuzugreifen. Die Funktionsdefinition verwendet Zeiger auf zwei Arten

| | – Aufruf durch Wert

• Aufruf durch Referenz |

Der Aufruf durch Referenz-Mechanismus ist schneller im Vergleich zum Aufruf durch Wert-Mechanismus, da beim Aufruf durch Referenz die Adresse übergeben wird und die Manipulation mit den Adressen schneller ist als mit den gewöhnlichen Variablen. Darüber hinaus wird nur ein Speicherort für jedes der tatsächlichen Parameter erstellt.

Wenn ein Teil des Programms, die tatsächlichen Argumente, eine Funktion aufruft und die Werte innerhalb der Funktion geändert werden, werden sie in der geänderten Form an den aufrufenden Teil des Programms zurückgegeben. Dies wird als Aufruf durch Referenz oder Aufruf durch Adresse bezeichnet. Die Verwendung von Zeigern als Funktionsargument in diesem Mechanismus ermöglicht es, die Datenobjekte global zu ändern, d.h. innerhalb der Funktion sowie innerhalb des aufrufenden Teils des Programms. Wenn ein Zeiger an die Funktion übergeben wird, wird die Adresse des Arguments an die Funktionen übergeben und die Inhalte dieser Adresse werden global zugegriffen. Die Änderungen, die an den formalen Parametern (Parametern, die in der Funktion verwendet werden) vorgenommen werden, wirken sich auf den ursprünglichen Wert der tatsächlichen Parameter (Parametern, die im aufrufenden Programm verwendet werden) aus.

Beispiel.

| | / 39_func.c /

void func_c( int *x );

int main()
{
int i = 100;
int *a;
a = &i;
printf(“\nDer Wert ist %d”, i);
func_c(a);
printf(“\nDer Wert ist %d”, i);
return 0;
}

void func_c( int x )
{
(x) ++;
printf(“\nDer Wert in der Funktion ist %d “, *x);
} |

In dem obigen Programm gibt es insgesamt drei ‘printf’-Anweisungen, zwei in der main()-Funktion und eine in der Funktionsunterprogramm. Aufgrund der Wirkung der ersten printf-Anweisung wird der Wert von i als 100 ausgegeben. Später wird ein Funktionsaufruf gemacht und innerhalb der Funktion wird der Wert geändert und beträgt 101 aufgrund der Erhöhung. Der geänderte Wert wird erneut an main() zurückgegeben und als 101 ausgegeben.

Daher ist die Ausgabe:

| | Der Wert ist 100
Der Wert in der Funktion ist 101
Der Wert ist 101 |

Mehr über Funktionsaufrufe

Nachdem wir die erste Begegnung mit Zeigern hatten, lassen Sie uns nun zu dem zurückkehren, was wir ursprünglich lernen wollten – die beiden Arten von Funktionsaufrufen: Aufruf durch Wert und Aufruf durch Referenz. Argumente können im Allgemeinen auf eine der beiden Arten an Funktionen übergeben werden:

| | a. Übermittlung der Werte der Argumente
b. Übermittlung der Adressen der Argumente |

2. Aufruf durch Wert

In der ersten Methode wird der ‘Wert’ jedes der tatsächlichen Argumente in der aufrufenden Funktion in die entsprechenden formalen Argumente der aufgerufenen Funktion kopiert. Mit dieser Methode haben die Änderungen, die an den formalen Argumenten in der aufgerufenen Funktion vorgenommen werden, keinen Einfluss auf die Werte der tatsächlichen Argumente in der aufrufenden Funktion. Das folgende Programm veranschaulicht den Aufruf durch Wert.

| | / 40_callbyvalue.c /
void swap( int x, int y )
int main( )
{
int a = 10, b = 20;
swap( a ,b );
printf(“\n a = %d, b = %d “, a, b);
return 0;
}
void swap( int x, int y )
{
int t;
t = x;
x = y;
y = t;
printf(“\nx = %d, y = %d”, x, y);
} |

Die Ausgabe des obigen Programms wäre:

| | X = 20 y = 10
A = 10 b = 20 |

Beachte, dass der Wert von a und b nach dem Austausch der Werte von x und y unverändert bleibt.

3. Aufruf durch Referenz

Diesmal werden die Adressen der tatsächlichen Argumente in der aufrufenden Funktion in die formalen Argumente der aufgerufenen Funktion kopiert. Das bedeutet, dass wir mit diesen Adressen Zugriff auf die tatsächlichen Argumente haben und sie somit manipulieren können. Das folgende Programm veranschaulicht diese Tatsache.

| | 41_callbyref.c /

void swap( int x, int y )

int main()
{
int a = 10, b = 20;
swap( &a, &b);
printf(“\na = %d, b = %d”, a, b);
return 0;
}

void swap( int x, int y )
{
int t;
t = x; x = y; y = t;
} |

Die Ausgabe des obigen Programms wäre:

| | A = 20, b = 10 |

Beachte, dass dieses Programm es schafft, die Werte von a und b mithilfe ihrer Adressen, die in x und y gespeichert sind, auszutauschen. Normalerweise machen wir in der C-Programmierung einen Aufruf durch Wert. Das heißt, im Allgemeinen kannst du die tatsächlichen Argumente nicht ändern. Aber wenn gewünscht, kann dies immer durch einen Aufruf durch Referenz erreicht werden.

Intelligente Verwendung des Aufrufs durch Referenz

Wir können eine Funktion erstellen, die mehr als einen Wert gleichzeitig zurückgeben kann, was normalerweise nicht möglich ist. Dies wird im folgenden Programm gezeigt.

| | / 42_callbyref.c /

void areaperi(int r, float a, float p)

int main()
{
int radius;
float area, perimeter;
printf(“\nGib den Radius eines Kreises ein:”); scanf(“%d”, &radius);

areaperi(radius, &area, &perimeter);

printf(“\nFläche = %f “, area);
printf(“\nUmfang = %f”, perimeter);
return 0;
}

void areaperi(int r, float a, float p)
{
a = 3.14 r r; p = 2 3.14 r;
} |

Und hier ist die Ausgabe:

| | Gib den Radius eines Kreises 5 ein
Fläche = 78.500000
Umfang = 31.400000 |

Hier machen wir einen gemischten Aufruf, in dem wir den Wert von radius übergeben, aber die Adressen von area und perimeter. Und da wir die Adressen übergeben, wird jede Änderung, die wir an den Werten vornehmen, die an den Adressen gespeichert sind, die in den Variablen a und p enthalten sind, wirksam in main. Deshalb können wir, wenn die Kontrolle von der Funktion areaperi( ) zurückkehrt, die Werte von area und perimeter ausgeben.
Somit haben wir es geschafft, zwei Werte aus einer aufgerufenen Funktion zurückzugeben und damit die Einschränkung der return-Anweisung zu überwinden, die nur einen Wert aus einer Funktion gleichzeitig zurückgeben kann.

VII. Lokale vs Globale Variablen

Gemäß dem Geltungsbereich von Bezeichnern werden Variablen als Typen deklariert.

| | / 42_globalid.c /
int i=4000; / Deklaration einer globalen Variablen/
int main()
{
int a=10, b=20; / Lokale Variable /
int i=100; / Lokale Variable /
printf(“%d %d”, a, b);
printf(“\nLokale i : %d”, i); / Zugriff auf lokale Variable /
printf(“\nGlobale i : %d “, ::i); / Zugriff auf globale Variable /
return 0;
} |

Hinweis: Der Geltungsbereichsoperator ( :: ) kann nur in C++ verfügbar sein.

VIII. Speicherklassenspezifizierer

Bis zu diesem Punkt sind wir bereits mit der Deklaration von Variablen vertraut. Um eine Variable vollständig zu definieren, muss man nicht nur ihren ‘Typ’ angeben, sondern auch ihre ‘Speicherklasse‘.
Gemäß diesem Abschnitt haben Variablen nicht nur einen ‘Datentyp’, sondern auch eine ‘Speicherklasse’.

Speicherklassen sind in 4 Typen unterteilt

| | 1. Automatische Speicherklasse

2. Register-Speicherklasse
3. Statische Speicherklasse
4. Externe Speicherklasse |

1. Automatische Speicherklasse

Beispiel:

| | / 43_auto.c /
#include
int main()
{
auto int i, j;
printf(“%d %d”, i, u);
return 0;
} |

2. Register-Speicherklasse

Beispiel:

| | / 44_register.c /
#include
int main( )
{
register int i, j;
for(i=1;i<=10;i++)
printf(“\n%d”, i);
return 0;
} |

3. Statische Speicherklasse

Beispiel:

| | / 45_static.c /
#include
void add();
int main()
{
add();
add();
add();
return 0;
}
void add()
{
static int i = 1;
printf(“%d\n”,i++);
} |

4. Externe Speicherklasse

Beispiel:

| | / 46_extern.c /
#include
int i;
void add(); / Externe Variable /
int main( )
{
extern j=10; / Externe Variable /
for(i=1;i<=10;i++)
add();
return 0;
}
void add( )
{
j++;
printf(“%d %d\n”, i, j);
} |