Programmation évènementielle

Chapitre 3 : Les procédures et les fonctions

Objectif Général

Ce chapitre présente comment créer et appeler les procédures Sub et les fonctions Function,
comment structurer le code en utilisant des modules, comment transmettre des arguments par valeur
et par référence, et comment utiliser des fonctions prédéfinies

Objectifs Spécifiques
A la fin de ce chapitre les étudiants auront les connaissances nécessaires pour :

 créer et appeler les procédures (Sub) et les fonctions (Function) ;


 écrire des procédures dans des modules pour permettre la réutilisation du code ;

 transmettre des arguments par valeur et par référence ;

 utiliser des fonctions prédéfinies.

Pré-requis
Algorithmique, programmation.

Volume horaire
3 Heures

Table des matières

1. Les procédures .................................................................................................................................. 3

1.1. Transmission par valeur : ByVal .................................................................................................... 3
1.2. Transmission par référence : ByRef ............................................................................................... 4
2. Les Fonctions .................................................................................................................................... 5
3. Quelques fonctions globales ............................................................................................................. 6
3.1. Fonctions mathématiques ................................................................................................................ 6
3.2. Fonctions de chaîne de caractères ................................................................................................... 6

1
 Programmation évènementielle

4. Interruption de séquences ................................................................................................................... 7

5. Exercices d’application ...................................................................................................................... 8

2
 Programmation évènementielle

Chapitre 3 : Les procédures et les fonctions

1. Les procédures

Comme dans le cas du langage, VB.NET permet l’utilisation des procédures et des fonctions
avec ou sans paramètres. Rappelez-vous que la grande différence entre la procédure et la fonction
est que cette dernière retourne une valeur lorsqu’elle est appelée.

1.1. Transmission par valeur : ByVal

Pour transmettre un paramètre par valeur, celui-ci doit être obligatoirement précédé par le
mot réservé ByVal. Dans ce cas si la procédure appelée modifie la valeur de la variable d'origine, la
valeur initiale de la variable ne change pas. Lorsque l'exécution revient à la procédure appelante, la
variable contient la valeur qu'elle avait avant la transmission de la valeur.

Syntaxe :

Private Sub NomProcédure( ByVal argument As Type, … )

Instruction1

Instruction2

End Sub

Exemple :
Private Sub Affectation( ByVal valeur1, valeur2 As integer)

Dim Chaîne As String

Chaîne = "La somme de " & valeur1 & " et " & valeur2 & " = "
valeur1 = valeur1 + valeur2
Chaîne = Chaîne & valeur1
MsgBox (Chaîne)

End Sub

L’appel de la procédure se fait soit en inscrivant call suivi du nom de la procédure, et des
paramètres à lui transmettre, soit en écrivant uniquement le nom de la procédure, suivi des
paramètres à lui transmettre.
Exemple :

Dim X As integer

Dim Y As integer

Call Affectation (X, Y) ‘ avec les parenthèses

3
 Programmation évènementielle

MsgBox (" X = " & X & " n'a pas changé ")

1.2. Transmission par référence : ByRef

Si ByVal n’est pas précisé ou si le paramètre est précédé par le mot réservé ByRef, la
variable est transmise par référence (c à d a travers l’adresse des données en mémoire). Ainsi, toute
modification de la variable locale correspondante dans la procédure se reflète sur la variable utilisée
lors de l’appel. VB suppose que la transmission se fait par référence si le mot réservé ByVal est
omis.
Exemple :

Private Sub permutation ( valeur1 As Integer, valeur2 As Integer )

Dim variable As Integer

variable = valeur1

valeur1 = valeur2

valeur2 = variable

End Sub

L’appel suivant permute le contenu de X dans Y et inversement.

Exemple :

Dim X As Integer, Y As Integer

X=100

Y=200

MsgBox (" X = " & X & " et Y = " & Y)

permutation (X, Y)

MsgBox (" Alors que maintenant X = " & X & " et Y = " & Y)

1.3. Comparaison de deus type de transmission

Méthode de Explication Implications Avantage

transmission

Par valeur La procédure Si la procédure appelée modifie Évite que la

appelée reçoit une la copie, la valeur initiale de la variable ne soit
Mot clé : ByVal copie des données. variable ne change pas. Lorsque modifiée par la
l’exécution revient à la procédure appelée.
procédure appelante, la variable
contient la valeur qu’elle avait
avant la transmission de la
valeur.

4
 Programmation évènementielle

Par référence La procédure La procédure appelée peut La procédure

appelée reçoit une modifier directement la variable. appelée peut utiliser
Mot clé : ByRef référence aux Lorsque l’exécution revient à la l’argument pour
données initiales procédure appelante, la variable renvoyer une
(l’adresse des contient la valeur modifiée. nouvelle valeur au
données en code appelant.
mémoire).

Tableau 3.1 : La comparaison des types de transmission par valeur et par référence

2. Les Fonctions

Lors de la déclaration d'une fonction, la valeur qui doit être retournée par celle-ci doit être
affectée au nom de la fonction. La déclaration de la fonction se termine par les mots réservés End
function.
Syntaxe :

Private function NomFonction( Argument As Type, … ) As Type

Instruction1

Instruction2

NomFonction = RésultatDeLaFonction ‘ou bien return

RésultatDeLaFonction End function

Exemple :

Private Sub Affectation( ByVal valeur1, valeur2 As integer)

Dim Chaîne As String
Chaîne = "La somme de " & valeur1 & " et " & valeur2 & " = "
valeur1 = valeur1 + valeur2
Chaîne = Chaîne & valeur1
MsgBox (Chaîne)
End Sub

Private function Somme( valeur1 As Integer, valeur2 As Integer ) As integer

Somme = Valeur1 + valeur2

End function

L’appel suivant retourne la somme de X et Y et affecte le résultat à la variable Z.

Exemple :

Dim X As Integer, Y As Integer, Z As Integer

5
 Programmation évènementielle

X=10

Y=20

Z = Somme(X, Y)

3. Quelques fonctions globales

Les deux tableaux suivant résument quelques fonctions mathématiques et quelques fonctions pour
la manipulation des chaînes de caractères.
3.1. Fonctions mathématiques
Fonction Utilité Exemple

Abs(Nb) Donne la valeur absolue du nombre Abs (- 89) = 89

Atn(Angle) Donne l’arc tangente de l’angle Atn(0) = 0
Cos(Angle) Donne le cosinus de l’angle Cos(0) = 1
Exp(Nb) Donne l’exponentielle du nombre Exp(1) = 2.71828
Fix(Nb) Tronque les décimales du nombre Fix(-4.6) = -4
Fix(4.6) = 4
Int(Nb) Donne la partie entière du nombre Int et Fix ne Int(-4.6) = -5
diffèrent que pour les valeurs supérieures à 0 Int(4.6) = 4
Log(Nb) Donne le logarithme naturel (base e) Log(1) = 0
Sgn(Nb) Donne le signe du nombre : 1, 0 ou –1 Sgn(- 89) -1
Sin(Angle) Donne le sinus du nombre Sin(0) = 0
Sqr(Nb) Donne la racine carrée du nombre Sqr(4) = 2
Tan(Angle) Donne la tangente de l’angle Tan(0) = 0
Round(Nb) Arrondi à la valeur Round(4.5) = 4
supérieure si (Nb - Int(Nb) ) > 5 Round(4.51) = 5
inférieure si (Nb - Int(Nb) ) <= 5

Tableau 3.2 : Les fonctions mathématiques

3.2. Fonctions de chaîne de caractères

Fonction Utilité Exemple

Asc(Car) Donne le code ASCII d’un caractère Asc(“A”) = 65

Chr(N ) Donne le caractère correspondant au code Chr(65) = “A”
ASCII

6
 Programmation évènementielle

Len(Chaîne) Donne la longueur d’une chaîne Len(“Orange”) =6

Lcase(Chaîne) Transforme la chaîne en minuscules Lcase(“ABC”)= “abc”
UCase(Chaîne) Transforme la chaîne en majuscules Ucase(“abc”)= “ABC”
LTrim(Chaîne) Supprime les espaces de tête LTrim(“ Hello”)=“Hello”
RTrim(Chaîne) Supprime les espaces de fin LTrim(“Hello ”)=“Hello”
Trim(Chaîne) Supprime les espaces de tête et de fin Trim(“ Hello ”)=“Hello”
Left(Chaîne, N) Renvoie les N caractères de gauche Left(“Auto”,2)= “Au ”
Right(Chaîne, N) Renvoie les N caractères de droite Right(“Auto”,2)= “to ”
Mid(Chaîne, Pos, N) Renvoie N caractères à partir de la position Mid(“Locom”, 3, 2) = “co”
Pos
nStr(Chaîne, Car) Renvoie la position de la première occurrence InStr (“Locom”,“o”) = 2
du caractère dans la chaîne ou la valeur 0 si la InStr (“Locom”,“a”) = 0
chaîne ne contient pas le caractère
Val(Chaîne) Convertit en nombre les chiffres d’une chaîne Val(“123”) = 123
(la conversion s’arrête au premier caractère Val(“123abcd”) = 123
qui n’est pas un chiffre, ou à 0 s’il n’y a pas Val(“abcd123”) = 0
de chiffre en tête)
Str(N) Convertit N en chaîne de caractères Str(123) = “123”
tring(N, Car) Génère N fois le caractère spécifié String(4, “A”) = “AAAA”
Space(N) Génère des espaces Space(4) = “ ”

Tableau 3.3 : Les fonctions de chaîne de caractères

2. Interruption de séquences

Pour interrompre l’exécution d’une séquence d’instructions (dans une fonction, procédure
ou boucle For), on utilise l’instruction Exit. Le tableau suivant résume son utilisation.

Instruction Porté Description

Exit function Limitée à la fonction Interruption de la fonction, sans exécution des

instructions restantes

Exit Sub Limitée à la procédure Interruption de la procédure, sans exécution

des instructions restantes

Exit For Limitée à la boucle For Interruption de la boucle, sans exécution des
instructions restantes

Exit Do Limitée à la boucle Do Interruption de la boucle, sans exécution des

7
 Programmation évènementielle

instructions restantes

Tableau 3.4 : Les instructions d’interruption de séquences

3. Exercices d’application

Soit l’interface suivante :

1. Créer les fonctions suivantes : addition, soustraction, multiplication, division.

2. En cliquant sur le bouton calculer, on doit avoir le résultat approprié selon la
case option sélectionné.
3. Programmer le bouton Quitter.

Solution :
Public Class Calculatrice

'Les fonctions

Private Function addition(ByVal a As Integer, ByVal b As Integer)

Return a + b
End Function
Private Function soustraction(ByVal a As Integer, ByVal b As Integer)
Return a - b
End Function
Private Function multiplication(ByVal a As Integer, ByVal b As Integer)
Return a * b
End Function

8
 Programmation évènementielle

Private Function division(ByVal a As Integer, ByVal b As Integer)

If b = 0 Then
MsgBox("division par ZERO impossible!!!", MsgBoxStyle.Information,
"ZERO!!")
End If
Return a / b
End Function

'Les procédures

Private Sub txtnum1_TextChanged(ByVal sender As System.Object, ByVal e

As System.EventArgs) Handles txtnum1.TextChanged
If (txtnum1.TextLength > 0) Then
If Not IsNumeric(txtnum1.Text) Then
txtnum1.ResetText()
MsgBox("veuillez entrez un nombre", MsgBoxStyle.Information,
"nombre1")
End If
End If
End Sub

Private Sub txtnum2_TextChanged(ByVal sender As System.Object, ByVal e

As System.EventArgs) Handles txtnum2.TextChanged
If (txtnum2.TextLength > 0) Then
If Not IsNumeric(txtnum2.Text) Then
txtnum2.ResetText()
MsgBox("veuillez entrez un nombre", MsgBoxStyle.Information,
"nombre2")
End If
End If
End Sub

Private Sub BtnCalculer_Click(ByVal sender As System.Object, ByVal e

As System.EventArgs) Handles BtnCalculer.Click
If RAdd.Checked = True Then
txtres.Text = addition(CInt(txtnum1.Text),
CInt(txtnum2.Text)) End If
If RSous.Checked = True Then
txtres.Text = soustraction(CInt(txtnum1.Text),
CInt(txtnum2.Text)) End If
If RMul.Checked = True Then
txtres.Text = multiplication(CInt(txtnum1.Text),
CInt(txtnum2.Text)) End If
If RDiv.Checked = True Then
txtres.Text = division(CInt(txtnum1.Text),
CInt(txtnum2.Text)) End If
End Sub

Private Sub BtnQuitter_Click(ByVal sender As System.Object, ByVal e

As System.EventArgs) Handles BtnQuitter.Click
Dim msg
msg = MsgBox("voulez vous vraiment quitter l'application ?
", MsgBoxStyle.YesNo Or MsgBoxStyle.Question, "Quitter")
If msg = vbYes Then
End
End If
End Sub
End Class