Une sous-routine est une partie distincte d'un programme qui a un nom et résout sa propre tâche distincte. Le sous-programme est situé au début du programme principal et peut être lancé (appelé) à partir du programme principal en spécifiant le nom.
L'utilisation de sous-routines vous permet d'éviter la duplication de code si vous devez écrire le même code à différents endroits programmes .
Les bibliothèques importées dans un programme (par exemple, Système) sont constituées de routines qui ont déjà été compilées par quelqu'un. Les programmeurs n'ont pas à réfléchir aux algorithmes qui y sont implémentés, ils les appliquent simplement, en pensant uniquement à ce qu'ils font exactement. C'est un gain de temps considérable. Il n'est pas nécessaire d'écrire un algorithme qui a déjà été écrit par quelqu'un d'autre.
Chaque sous-programme ne doit effectuer qu'une seule tâche, soit calculer quelque chose, soit produire des données, soit faire autre chose.
Les sous-routines, ou méthodes, sont de deux types - fonctions (celles qui renvoient le résultat du travail) et procédures (celles qui ne le font pas).
Commençons par le deuxième type. Essayons d'écrire un exemple simple.
Supposons que nous ayons besoin d'afficher la chaîne "Erreur" à l'écran chaque fois qu'une erreur peut se produire dans le code en raison de la faute de l'utilisateur (par exemple, lorsqu'il saisit des données incorrectes).
Cela peut être fait en écrivant la déclaration
Console.WriteLine("Erreur");
Imaginons maintenant que cette ligne doit être insérée à plusieurs endroits dans le programme. Bien sûr, vous pouvez simplement l'écrire partout. Mais cette solution a deux inconvénients.
1) cette chaîne sera stockée en mémoire plusieurs fois ;
2) si nous voulons changer la sortie en cas d'erreur, nous devrons changer cette ligne tout au long du programme, ce qui est plutôt gênant.
Pour de tels cas, des méthodes et des procédures sont nécessaires.
Un programme avec une procédure pourrait ressembler à ceci :
à l'aide de System ;
classeProgramme {
statique vide PrintError() {
Console.WriteLine("Erreur");
}
statique void Main() {
PrintError();
}
}
Une procédure commence par le mot void. Après le nom de procédure des crochets vides sont écrits.
Toutes les instructions exécutées dans une procédure sont mises en retrait.
Le modificateur Static signifie que le champ, la méthode ou la propriété donnée n'appartiendra pas à chaque objet de la classe, mais à tous ensemble.
Les méthodes et les procédures sont écrites avant la méthode principale Main().
Pour faire référence à une procédure, dans le programme principal, vous devez l'appeler par son nom et ne pas oublier d'écrire des parenthèses.
Vous pouvez appeler une procédure dans un programme autant de fois que vous le souhaitez.
|
Imaginons maintenant que nous devons afficher différents messages en réponse à une erreur de l'utilisateur, selon que exactement quelle erreur il a commise.
Dans ce cas, vous pouvez écrire votre propre procédure pour chaque erreur :
annuler printErrorZero()
{
Console.WriteLine("Erreur. Division par zéro!");
}
annuler printErrorInput()
{
Console.WriteLine("Erreur dans l'entrée!");
}
Et s'il y a beaucoup plus d'erreurs possibles ? Alors cette solution ne nous conviendra pas.
Nous devons apprendre à contrôler la procédure en lui indiquant quel message d'erreur afficher.
Pour ce faire, nous avons besoin de paramètres que nous écrirons entre parenthèses après le nom de la procédure
void printError(string s)
{
Console.WriteLine(s);
}
Dans cette procédure, s est un paramètre - une variable spéciale qui permet de contrôler la procédure.
Le paramètre est une variable dont dépend le fonctionnement de la sous-routine. Les noms des paramètres sont répertoriés séparés par des virgules dans l'en-tête du sous-programme. Le type de paramètre est écrit avant le paramètre.
Maintenant, lors de l'appel de la procédure, vous devez spécifier la valeur réelle entre parenthèses qui sera attribuée au paramètre (la variable s) à l'intérieur de notre procédure
printError("Erreur ! Division par zéro !");
Cette valeur est appelée un argument.
L'argument est la valeur du paramètre qui est transmise à la sous-routine lorsqu'elle est appelée.
L'argument peut être non seulement une valeur constante, mais aussi une variable ou une expression arithmétique.< /span>< /span>
|
Variables locales et globales
Il est souvent nécessaire d'utiliser des variables supplémentaires qui ne seront utilisées que dans le sous-programme. De telles variables sont appelées locales (ou locales) et ne peuvent être manipulées qu'au sein du sous-programme dans lequel elles sont créées.
La portée de la variable locale est le bloc entre accolades dans lequel elle est déclarée.
Le programme principal en C# est également une sous-routine, donc toutes les variables déclarées dans void Main() sont des variables locales. Les autres sous-programmes ne "savent" rien des variables locales des autres sous-programmes.
Ainsi, il est possible de limiter la portée (portée) d'une variable uniquement au sous-programme où elle est vraiment nécessaire. En programmation, cette technique est appelée encapsulation - empêcher la variable de la modifier de l'extérieur.
S'il est nécessaire de déclarer une variable qui serait visible n'importe où dans le programme (dans n'importe quel sous-programme), alors ces variables sont déclarées en dehors de tous les sous-programmes (voir le programme 3 du tableau ci-dessous).
Ces variables sont appelées globales.
En C#, au démarrage du programme, toutes les variables globales sont automatiquement mises à zéro (les variables booléennes prennent la valeur false).
Analysez trois programmes :
| 1) Dans ce programme, la variable i est locale. Une variable locale est déclarée à l'intérieur d'un sous-programme. |
2) Ici, même s'il y a une variable i dans le programme principal (avec la valeur 7), une nouvelle variable locale i avec la valeur 5 sera créée.
Lorsque ce programme est exécuté, la valeur 75 apparaîtra à l'écran. |
3) Ce programme a une variable globale i. Sa valeur peut être modifiée à l'intérieur du sous-programme et à l'intérieur du programme principal.
La procédure fonctionnera avec la variable globale i et lui attribuera une nouvelle valeur égale à 2. La valeur 2 s'affiche. |
test de vide statique()
{
int je = 5 ;
Console.Write("je");
}
test de vide statique()
{
int je = 5 ;
Console.Write("je");
}
vide statique Main()
{
int je = 7 ;
Console.Write("je");
test();
}
utiliser le système ;
Programme de classe
{
int je ;
test de vide statique()
{
je = 2 ;
}
vide statique Main()
{
test();
Console.Write("je");
}
}
|
Tâche
Écrivez une procédure qui échange les valeurs de deux variables.
La particularité de cette tâche est que nous avons besoin que les modifications apportées à la procédure soient connues du programme appelant.
Essayons d'écrire la procédure comme ceci :
static void Swap (int a, int b) // avec une telle description des paramètres de la procédure,
{ // va copier les valeurs des arguments (x et y)
entier c ; // les variables a et b sont des variables indépendantes non liées à x et y
c = un ; un = b ; b=c ;
}
vide statique Main()
{
entier x=1, y=2 ;
Échange(x, y); //les valeurs des variables x et y (arguments) sont copiées dans les paramètres a et b, x = 1, y = 2
}
Si vous exécutez ce programme, vous pouvez voir que les valeurs des variables x et y n'ont pas changé. Pour que les paramètres modifient les valeurs des arguments, vous devez utiliser des données passant par référence. Pour cela, avant le nom du type de données dans l'en-tête du sous-programme, vous devez écrire ref .
void Swap ( ref int a, ref int b ) // maintenant les variables a et b obtiennent les adresses des variables x et y en mémoire
{
entier c ;
c = un ; un = b ; b=c ;
}
vide statique Main()
{
entier x=1, y=2 ;
Swap(réf x, réf y);
Application : si vous passez un argument par référence, alors seul le nom de la variable (PAS un nombre et PAS une expression arithmétique) peut figurer à cet endroit lors de l'appel de la procédure.
Vous ne pouvez pas appeler une procédure comme celle-ci :
Échange(x, 4);
Échange(5+x, y);
|