Travailler avec des fonctions en C ++

Développeurs souvent besoin de la capacité de briser les programmes en petits morceaux qui sont plus faciles à développer. Les programmes de «monde réel» peuvent être nombreuses de milliers (voire des millions!) De lignes longues. Sans cette capacité à diviser le programme en deux parties, l'élaboration de ces grands programmes deviendrait rapidement impossible.

C ++ permet aux programmeurs de diviser leur code en morceaux appelés fonctions. Une fonction avec une description simple et une interface bien définie pour le monde extérieur peut être écrit et de débogage sans se soucier du code qui l'entoure.

Surcharge des noms de fonction

C ++ permet au programmeur d'attribuer le même nom à deux ou plusieurs fonctions. Cette utilisation multiple de noms est connu comme fonctions surcharge ou, tout simplement, surcharge.

En général, deux fonctions dans un seul programme ne peuvent pas partager le même nom. Si elles le faisaient, C ++ aurait aucun moyen de les distinguer.

Toutefois, le nom de la fonction inclut le nombre et le type des arguments. (Le nom de la fonction ne comprend pas son argument de retour.) Ainsi, les suivantes ne sont pas les mêmes fonctions:

someFunction void (void)
{
// .... Effectuer une certaine fonction
}
someFunction (int n)
{
// ... Effectuer une fonction différente
}
someFunction void (double d)
{
// ... Effectuer une fonction très différente
}
someFunction (int n1, n2 int)
{
// .... Faire quelque chose de différent encore
}

C ++ sait encore que les fonctions someFunction (void), someFunction (int), someFunction (double), et someFunction (int, int) ne sont pas les mêmes. Comme beaucoup de choses qui traitent avec les ordinateurs, ce qui a une analogie dans le monde humain.

vide comme type d'argument est facultatif. sumFunction (void) et sumFunction () sont la même fonction. Une fonction a un nom raccourci, comme someFunction (). Aussi longtemps que nous utilisons le nom en entier, ne se confond - peu importe combien de someFunctions il peut y avoir. Le nom complet de l'un des (someFunctions)est someFunction (int). Tant que ce nom est unique, pas de confusion se produit.

Une application typique peut apparaître comme suit:

intVariable1 int, // équivalent à intVariable2-
// Int Variable1-
// Int Variable2-
à double doubleVariable-
// Fonctions se distinguent par le type de
// L'argument passé
someFunction () - // appelle someFunction (void)
someFunction (intVariable1) - // appelle someFunction (int)
someFunction (doubleVariable) - // appelle someFunction (double)
someFunction (intVariable1, intVariable2) - // appels
// SomeFunction (int, int)
// Cela fonctionne constantes ainsi
someFunction (1) - // appelle someFunction (int)
someFunction (1,0) - // appelle someFunction (double)
someFunction (1, 2) - // appelle someFunction (int, int)

Dans chaque cas, le type des arguments correspond le nom complet des trois fonctions.

Le type de retour ne fait pas partie du nom développé (également connu sous le nom signature de fonction) De la fonction. Les deux fonctions suivantes ont le même nom et, par conséquent, ne peuvent pas faire partie du même programme:

int someFunction (int n) - // nom complet de la fonction
// Est someFunction (int)
à double someFunction (int n) - // même nom

Le texte suivant est acceptable:

int someFunction (int n) -
Double D = someFunction (10) - // promouvoir valeur retournée

La int retournée par someFunction () est promu dans un double. Ainsi, le suivant serait source de confusion:

int someFunction (int n) -
à double someFunction (int n) -
Double D = someFunction (10) - // promouvoir int retourné?
// Ou l'utilisation retourné deux fois comme il est

C ++ serait de savoir si l'utilisation de la valeur retournée par la double version de someFunction () ou de promouvoir la valeur retournée par int la version.

Définir les prototypes de fonctions

Le programmeur peut fournir le reste d'un C ++ fichier source, ou du module, le nom élargie (le nom et les fonctions) lors de la définition de la fonction.

Une fonction peut être défini n'importe où dans le module. (UN module est un autre nom pour le fichier source d'un C). Cependant, quelque chose a dire main () le nom complet de la fonction avant qu'il puisse être appelé. Considérons le code suivant:

int main (int argc, char * pargs [])
{
someFunc (1, 2) -
}
int someFunc (à double arg1, arg2 int)
{
// ...faire quelque chose
}

L'appel à la someFunc () de l'Intérieur main () ne sais pas le nom complet de la fonction. Il peut conjecturer à partir des arguments que le nom est someFunc (int, int) et que son type de retour est toutefois void-, comme vous pouvez le voir, ce qui est faux.

C ++ pourrait être moins paresseux et regarder vers l'avenir pour déterminer le nom complet de someFunc ()s sur son propre, mais il ne le fait pas. Ce qui est nécessaire est un moyen d'informer main () du nom complet du someFunc () avant son utilisation. Ce qui est nécessaire est un avant la déclaration de la fonction de l'utilisation. Certains type de prototype est nécessaire.

UN déclaration de prototype apparaît même comme une fonction sans corps. En utilisation, une déclaration de prototype se présente comme suit:

int someFunc (double, int) -
int main (int argc, char * pargs [])
{
someFunc (1, 2) -
}
int someFunc (à double arg1, arg2 int)
{
// ...faire quelque chose
}

La déclaration de prototype raconte le monde (au moins cette partie du monde après la déclaration), que le nom étendu pour someFunc () est someFunction (double, int). L'appel en main () sait maintenant de lancer le 1 à une double avant de faire l'appel. De plus, main () sait que la valeur renvoyée par someFunc () est un int.

Un appel de fonction qui retourne une valeur est un expression. Comme avec tout autre fournir une expression, vous êtes autorisé à jeter la valeur renvoyée par une fonction.

Types de stockage variable

Variables de fonction sont stockés dans trois endroits différents. Les variables déclarées dans une fonction sont dits locale. Dans l'exemple suivant, la variable localVariable est locale à la fonction fn ():

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

La variable localVariable ne pas exister jusqu'à ce que la fonction fn () est appelé. localVariable cesse d'exister lorsque la fonction retourne. À son retour, quelle que soit la valeur qui est stockée dans localVariable est perdu. En outre, seulement fn () a accès à localVariable - autres fonctions ne peuvent pas atteindre dans la fonction pour y accéder.

Par comparaison, la variable globalVariable existe tant que le programme est exécuté. Toutes les fonctions ont accès à globalVariable tout le temps.

La variable statique staticVariable est quelque chose d'un mélange entre un local et une variable globale. La variable staticVariable est créé lorsque l'exécution atteint d'abord la déclaration (en gros, lorsque la fonction fn () est appelé). De plus, staticVariable est uniquement accessible au sein de fn (). Contrairement localVariable, cependant, staticVariable continue d'exister même après le programme revient de fn (). Si fn () attribue une valeur à staticVariable une fois, il sera toujours là la prochaine fois que fn () est appelé.

Au cas où quelqu'un demande, il ya un quatrième type, auto, mais aujourd'hui, il a la même signification que local, si juste les ignorer.