Arbeiten mit Funktionen in C ++

Entwickler müssen oft die Möglichkeit, Programme in kleinere Stücke zu brechen, die einfacher zu entwickeln sind. "Realen Welt" Programme können viele Tausende (oder Millionen!) Zeilen lang. Ohne diese Fähigkeit, das Programm in Teile zu zerlegen, so große Programme entwickeln würde schnell unmöglich werden.

C ++ ermöglicht es Programmierern, ihren Code zu unterteilen in Stücke bekannt als Funktionen. Eine Funktion mit einer einfachen Beschreibung und eine gut definierte Schnittstelle zur Außenwelt kann, ohne sich Gedanken über den Code geschrieben und getestet werden, die es umgibt.

Eine Überlastung Funktionsnamen

C ++ ermöglicht es dem Programmierer den gleichen Namen an zwei oder mehr Funktionen zuzuordnen. Diese mehrfache Verwendung von Namen ist bekannt als Überlastung Funktionen oder einfach, Überlastung.

Im Allgemeinen zwei Funktionen in einem einzigen Programm können nicht den gleichen Namen teilen. Wenn sie es täten, würde C ++ keine Möglichkeit, sie zu unterscheiden.

Jedoch enthält der Name der Funktion, um die Anzahl und den Typ der Argumente. (Der Name der Funktion beinhaltet nicht seine Rückkehr Argument.) Somit ist die folgende sind nicht die gleichen Funktionen:

Leere Funktion (void)
{
// .... Führen eine Funktion
}
Leere Funktion (int n)
{
// ... Führen eine andere Funktion
}
Leere Funktion (double d)
{
// ... Führen eine ganz andere Funktion
}
Leere Funktion (int n1, n2 int)
{
// .... Etwas anderes noch
}

C ++ weiß immer noch, dass die Funktionen Funktion (void), Funktion (int), Funktion (Doppelzimmer), und Funktion (int, int) sind nicht das Gleiche. Wie so viele Dinge, die mit Computern umgehen, hat dies eine Analogie in der menschlichen Welt.

Leere als Argument Typ ist optional. sumFunction (void) und sumFunction () sind die gleiche Funktion. Eine Funktion hat eine Kurznamen wie Funktion (). Solange wir den ganzen Namen verwenden, wird niemand verwirrt - egal, wie viele someFunctions es kann sein. Der vollständige Name für einen der someFunctions ()ist Funktion (int). Solange diese vollständige Name eindeutig ist, tritt keine Verwirrung.

Eine typische Anwendung kann wie folgt aussehen:

int intVariable1, intVariable2- // entspricht
// Int Variable1-
// Int Variable2-
Doppel doubleVariable-
// Funktionen werden durch die Art unterscheiden von
// Das Argument übergeben
Funktion () - // somefunction ruft (void)
Funktion (intVariable1) - // somefunction ruft (int)
Funktion (doubleVariable) - // somefunction ruft (double)
Funktion (intVariable1, intVariable2) - // Anrufe
// Funktion (int, int)
// Dies funktioniert für Konstanten als auch
Funktion (1) - // ruft Funktion (int)
Funktion (1.0) - // somefunction ruft (double)
Funktion (1, 2) - // ruft Funktion (int, int)

In jedem Fall entspricht die Art der Argumente, den vollständigen Namen der drei Funktionen.

Der Rückgabetyp ist nicht Teil des erweiterten Namens (auch bekannt als die Funktionssignatur) Der Funktion. Die folgenden zwei Funktionen haben den gleichen Namen und somit nicht Teil des gleichen Programms sein kann:

int Funktion (int n) - // vollständige Name der Funktion
// Ist Funktion (int)
Doppelfunktion (int n) - // gleichen Namen

Im Folgenden ist akzeptabel:

int Funktion (int n) -
double d = Funktion (10) - // fördern Rückgabewert

Das int kehrte nach Funktion () wird in ein gefördert doppelt. Somit wäre die folgende verwirrend:

int Funktion (int n) -
Doppelfunktion (int n) -
double d = Funktion (10) - // zurück int fördern?
// Oder Gebrauch zurückgegeben Doppel wie

C ++ würde wissen, ob der Wert aus der zurück zu verwenden doppelt Version von Funktion () oder zu fördern, um den Wert zurück aus int Version.

Definieren von Funktionsprototypen

Der Programmierer kann den Rest einer C ++ Quelldatei oder das Modul zur Verfügung stellen, der erweiterte Name (der Name und Funktionen) bei der Definition der Funktion.

Eine Funktion kann irgendwo in dem Modul definiert werden. (EIN Modul Allerdings ist ein anderer Name für eine Quelldatei C ++.), Etwas zu sagen hat Main() der vollständige Name der Funktion, bevor sie aufgerufen werden. Betrachten Sie den folgenden Code-Schnipsel:

int main (int argc, char * pargs [])
{
someFunc (1, 2) -
}
int someFunc (Doppel arg1, int arg2)
{
// ...Tu etwas
}

Der Aufruf someFunc () von innen Main() weiß nicht, den vollständigen Namen der Funktion. Es kann von den Argumenten vermuten, dass der Name ist someFunc (int, int) und dass deren Rückgabetyp ist void- aber wie Sie sehen können, ist dies falsch.

C ++ könnte weniger faul und nach vorne schauen Sie den vollständigen Namen zu bestimmen, von someFunc ()s auf seine eigene, aber es funktioniert nicht. Was benötigt wird, ist eine Möglichkeit zu informieren, Main() der vollständige Name someFunc () bevor es verwendet wird. Was wir brauchen, ist eine vor Gebrauch Funktionsdeklaration. Eine bestimmte Art von Prototyp ist notwendig.

EIN Prototyp Erklärung erscheint das gleiche ohne Körper als Funktion. Bei der Verwendung wird ein Prototyp Erklärung wie folgt:

int someFunc (double, int) -
int main (int argc, char * pargs [])
{
someFunc (1, 2) -
}
int someFunc (Doppel arg1, int arg2)
{
// ...Tu etwas
}

Der Prototyp Erklärung sagt der Welt (zumindest diesen Teil der Welt nach der Erklärung), dass der erweiterte Name für someFunc () ist Funktion (double, int). Der Aufruf in Main() Jetzt kennt die 1 zu einem doppelten, bevor sie den Anruf zu werfen. In Ergänzung, Main() weiß, dass der Rückgabewert von someFunc () ist ein int.

Ein Funktionsaufruf, der einen Wert zurückgibt, ist ein Ausdruck. Wie bei jedem anderen Ausdruck zur Verfügung stellen, dürfen Sie den Wert von einer Funktion zurück zu werfen.

Variable Speichertypen

Funktionsvariablen sind in drei verschiedenen Stellen gespeichert. Variablen, die innerhalb einer Funktion deklariert werden gesagt, lokal sein. Im folgenden Beispiel wird die Variable ortsveränderlichen ist auf die Funktion lokale fn ():

int globalVariable-
Leere fn ()
{
int localVariable-
static int staticVariable-
}

die Variable ortsveränderlichen nicht, bis die Funktion vorhanden fn () wird genannt. ortsveränderlichen hört auf zu existieren, wenn die Funktion zurückgibt. Nach der Rückkehr, dass alles, was Wert ist gespeichert in ortsveränderlichen ist verloren. Zusätzlich nur fn () hat Zugang zu ortsveränderlichen - Andere Funktionen können nicht in die Funktion zu erreichen, darauf zuzugreifen.

Zum Vergleich: die Variable globalVariable existiert, solange das Programm läuft. Alle Funktionen haben Zugriff auf globalVariable die ganze Zeit.

Die statische Variable staticVariable so etwas wie eine Mischung zwischen einem lokalen und einer globalen Variablen. die Variable staticVariable erstellt wird, wenn die Ausführung zunächst die Deklaration erreicht (etwa, wenn die Funktion fn () wird genannt). In Ergänzung, staticVariable ist nur innerhalb fn (). nicht wie ortsveränderlichen, aber, staticVariable bestehen bleibt, selbst nachdem das Programm kehrt aus fn (). Ob fn () ordnet einen Wert staticVariable einmal, es wird noch da sein, das nächste Mal fn () wird genannt.

Falls sich jemand fragt, gibt es eine vierte Art, Auto, aber heute hat die gleiche Bedeutung wie lokale, so einfach ignorieren.