Comment : modifier la valeur d'un argument de la procédure

Article
09/12/2008

Mise à jour : novembre 2007

Lorsque vous appelez une procédure, chaque argument que vous fournissez correspond à l'un des paramètres définis dans la procédure. Dans certains cas, le code de procédure peut modifier la valeur sous-jacente à un argument dans le code appelant. Dans d'autres cas, la procédure peut modifier uniquement sa copie locale d'un argument.

Lorsque vous appelez la procédure, Visual Basic fait une copie locale de chaque argument auquel est passé ByVal. Pour chaque argument auquel est passé ByRef, Visual Basic donne au code de procédure une référence directe à l'élément de programmation sous-jacent à l'argument dans le code appelant.

Si l'élément sous-jacent dans le code appelant est un élément modifiable et si ByRef est passé à l'argument, le code de procédure peut utiliser la référence directe pour modifier la valeur de l'élément dans le code appelant.

Modification de la valeur sous-jacente

Pour modifier la valeur sous-jacente d'un argument de procédure dans le code appelant

Dans la déclaration de procédure, spécifiez ByRef pour le paramètre correspondant à l'argument.
Dans le code appelant, passez un élément de programmation modifiable comme argument.
Dans le code appelant, ne mettez pas l'argument entre parenthèses dans la liste d'arguments.
Dans le code de procédure, utilisez le nom de paramètre pour assigner une valeur à l'élément sous-jacent dans le code appelant.

Consultez l'exemple ci-dessous pour une démonstration.

Modification de copies locales

Si l'élément sous-jacent dans le code appelant est un élément non modifiable ou si ByVal est passé à l'argument, la procédure ne peut pas modifier sa valeur dans le code appelant. Toutefois, la procédure peut modifier sa copie locale d'un tel argument.

Pour modifier la copie d'un argument de procédure dans le code de procédure

Dans la déclaration de procédure, spécifiez ByVal pour le paramètre correspondant à l'argument.

- ou -

Dans le code appelant, mettez l'argument entre parenthèses dans la liste d'arguments. Cela force Visual Basic à passer l'argument par valeur, même si le paramètre correspondant spécifie ByRef.
Dans le code de procédure, utilisez le nom de paramètre pour assigner une valeur à la copie locale de l'argument. La valeur sous-jacente dans le code appelant n'est pas modifiée.

Exemple

L'exemple suivant illustre deux procédures qui acceptent une variable tableau et opèrent sur ses éléments. La procédure increase ajoute simplement la valeur 1 à chaque élément. La procédure replace assigne un nouveau tableau au paramètre a(), puis ajoute la valeur 1 à chaque élément.

Public Sub increase(ByVal a() As Long)
    For j As Integer = 0 To UBound(a)
        a(j) = a(j) + 1
    Next j
End Sub

Public Sub replace(ByRef a() As Long)
    Dim k() As Long = {100, 200, 300}
    a = k
    For j As Integer = 0 To UBound(a)
        a(j) = a(j) + 1
    Next j
End Sub

Dim n() As Long = {10, 20, 30, 40}
Call increase(n)
MsgBox("After increase(n): " & CStr(n(0)) & ", " & _
    CStr(n(1)) & ", " & CStr(n(2)) & ", " & CStr(n(3)))
Call replace(n)
MsgBox("After replace(n): " & CStr(n(0)) & ", " & _
    CStr(n(1)) & ", " & CStr(n(2)) & ", " & CStr(n(3)))

Le premier appel MsgBox affiche "After increase(n): 11, 21, 31, 41". Étant donné que le tableau n est un type référence, replace peut modifier ses membres, même si le mécanisme de passage est ByVal.

Le deuxième appel MsgBox affiche "After replace(n): 101, 201, 301". Étant donné que ByRef est passé à n, replace peut modifier la variable n dans le code appelant et lui assigner un nouveau tableau. Étant donné que n est un type référence, replace peut également modifier ses membres.

Vous pouvez empêcher la procédure de modifier la variable elle-même dans le code appelant. Consultez Comment : protéger un argument de procédure contre les modifications de valeur.

Compilation du code

Lorsque vous passez une variable par référence, vous devez utiliser le mot clé ByRef pour spécifier ce mécanisme.

Le comportement par défaut en Visual Basic consiste à passer les arguments par valeur. En programmation, il est toutefois conseillé d'ajouter le mot clé ByVal ou ByRef avec chaque argument déclaré. Cela rend votre code plus lisible.

Sécurité

Permettre à une procédure de modifier la valeur sous-jacente à un argument dans le code appelant est toujours risqué. Vérifiez que cette valeur doit bien être modifiée et préparez-vous à en vérifier la validité avant de l'utiliser.