Tableaux dans Visual Basic
Un tableau est un ensemble de valeurs liées de manière logique, telles que le nombre d'étudiants de chaque niveau scolaire dans un lycée.
En utilisant un tableau, vous pouvez faire référence à ces valeurs connexes par le même nom et utiliser un numéro qui est appelé index ou indice pour les distinguer. Les valeurs individuelles portent le nom d'éléments du tableau. Elles sont contiguës de l'index 0 jusqu'à la valeur d'index la plus élevée.
Une variable qui contient une valeur unique est appelée variable scalaire.
Dans cette rubrique
Éléments de tableau dans un tableau simple
Création d'un tableau
Déclaration d'un tableau
Stockage de valeurs dans un tableau
Remplissage d'un tableau avec des valeurs initiales
- Littéraux de tableaux imbriqués
Itération via un tableau
Tableaux comme valeurs de retour et paramètres
Tableaux multidimensionnels
Tableaux de longueur zéro
Taille de tableau
Types tableau et autres types
Les collections en tant qu'alternative aux tableaux
Éléments de tableau dans un tableau simple
L'exemple suivant déclare une variable tableau devant contenir le nombre d'étudiants de chaque niveau scolaire dans un lycée.
Dim students(6) As Integer
Le tableau students de l'exemple précédent contient sept éléments. Les index des éléments varient de 0 à 6. Il est plus simple d'utiliser ce tableau que de déclarer sept variables.
L'illustration suivante représente le tableau students. Pour chaque élément du tableau :
l'index de l'élément représente le niveau scolaire (l'index 0 représente le jardin d'enfants) ;
La valeur qui est contenue dans l'élément représente le nombre d'étudiants dans ce niveau scolaire.
Éléments du tableau « students »
.gif "Image d'un tableau montrant le nombre d'étudiants")
L'exemple suivant montre comment faire référence aux premier, deuxième et dernier éléments du tableau students.
Dim kindergarten As Integer = students(0)
Dim firstGrade As Integer = students(1)
Dim sixthGrade As Integer = students(6)
MsgBox("Students in kindergarten = " & CStr(kindergarten))
MsgBox("Students in first grade = " & CStr(firstGrade))
MsgBox("Students in sixth grade = " & CStr(sixthGrade))
Vous pouvez faire référence au tableau dans son ensemble en utilisant uniquement le nom de variable tableau sans index.
Le tableau students de l'exemple précédent utilise un index et est unidimensionnel. Un tableau qui utilise plusieurs index ou indices est multidimensionnel. Pour plus d'informations, consultez le reste de cette rubrique et Dimensions du tableau dans Visual Basic.
Création d'un tableau
Vous pouvez définir la taille d'un tableau de plusieurs façons. Vous pouvez spécifier la taille lorsque le tableau est déclaré, comme indiqué dans l'exemple suivant.
Dim cargoWeights(10) As Double
Dim atmospherePressures(2, 2, 4, 10) As Short
Dim inquiriesByYearMonthDay(20)()() As Byte
Vous pouvez également utiliser une clause New pour fournir la taille d'un tableau lors de sa création, comme indiqué dans l'exemple suivant.
cargoWeights = New Double(10) {}
atmospherePressures = New Short(2, 2, 4, 10) {}
inquiriesByYearMonthDay = New Byte(20)()() {}
Si vous disposez déjà d'un tableau, vous pouvez redéfinir sa taille à l'aide de l'instruction Redim. Vous pouvez spécifier que l'instruction Redim doit conserver les valeurs actuellement stockées dans le tableau ou qu'elle crée un tableau vide. L'exemple suivant illustre différentes façons d'utiliser l'instruction Redim pour modifier la taille d'un tableau existant.
' Assign a new array size and retain the current element values.
ReDim Preserve cargoWeights(20)
' Assign a new array size and retain only the first five element values.
ReDim Preserve cargoWeights(4)
' Assign a new array size and discard all current element values.
ReDim cargoWeights(15)
Pour plus d'informations, consultez ReDim, instruction (Visual Basic).
Déclaration d'un tableau
Vous pouvez déclarer des variables tableau de la même façon que les autres variables, à l'aide de l'instruction Dim. Le type ou le nom de la variable est suivi d'une ou de plusieurs paires de parenthèses pour indiquer qu'elle contient un tableau et non une variable scalaire (une variable contenant une valeur unique).
Après avoir déclaré le tableau, vous pouvez définir sa taille à l'aide de ReDim, instruction (Visual Basic).
L'exemple suivant déclare une variable tableau de type unidimensionnel en ajoutant une paire de parenthèses après le type. L'exemple indique également les dimensions du tableau à l'aide de ReDim, instruction (Visual Basic).
' Declare a one-dimensional array.
Dim cargoWeights As Double()
' Dimension the array.
ReDim cargoWeights(15)
L'exemple suivant déclare une variable tableau de type multidimensionnel en ajoutant une paire de parenthèses après le type et en plaçant des virgules dans les parenthèses pour séparer les dimensions. L'exemple indique également les dimensions du tableau à l'aide de ReDim, instruction (Visual Basic).
' Declare a multidimensional array.
Dim atmospherePressures As Short(,,,)
' Dimension the array.
ReDim atmospherePressures(1, 2, 3, 4)
Pour déclarer une variable de tableau multidimensionnel, ajoutez une paire de parenthèses après le nom de la variable pour chaque niveau du tableau imbriqué.
Dim inquiriesByYearMonthDay()()() As Byte
Les exemples précédents montrent comment déclarer des variables tableau, mais aucun tableau n'est assigné à ces dernières. Vous devez encore créer un tableau, l'initialiser et l'assigner à la variable.
Stockage de valeurs dans un tableau
Dans un tableau, vous pouvez accéder à chaque emplacement à l'aide d'un index de type Integer. Vous pouvez stocker des valeurs dans un tableau et en récupérer en référençant chaque emplacement de tableau à l'aide de son index, placé entre parenthèses. Les index des tableaux multidimensionnels sont séparés par des virgules (,). Vous avez besoin d'un index pour chaque dimension du tableau. L'exemple suivant montre quelques instructions qui stockent des valeurs dans des tableaux.
Dim i = 4
Dim j = 2
Dim numbers(10) As Integer
Dim matrix(5, 5) As Double
numbers(i + 1) = 0
matrix(3, j * 2) = j
L'exemple suivant montre des instructions qui obtiennent des valeurs à partir de tableaux.
Dim v = 2
Dim i = 1
Dim j = 1
Dim k = 1
Dim wTotal As Double = 0.0
Dim sortedValues(5), rawValues(5), estimates(2, 2, 2) As Double
Dim lowestValue = sortedValues(0)
wTotal += (rawValues(v) ^ 2)
Dim firstGuess = estimates(i, j, k)
Remplissage d'un tableau avec des valeurs initiales
En utilisant un littéral de tableau, vous pouvez créer un tableau qui contient un ensemble initial de valeurs. Un littéral de tableau se compose d'une liste de valeurs séparées par des virgules et placées entre accolades ({}).
Lorsque vous créez un tableau à l'aide d'un littéral de tableau, vous pouvez indiquer le type de tableau ou le déterminer au moyen de l'inférence de type. Le code suivant présente les deux options.
Dim numbers = New Integer() {1, 2, 4, 8}
Dim doubles = {1.5, 2, 9.9, 18}
Lorsque vous utilisez l'inférence de type, le type du tableau est déterminé par le type dominant dans la liste de valeurs qui est fournie pour le littéral de tableau. Le type dominant est un type unique auquel tous les autres types présents dans le littéral de tableau peuvent s'étendre. Si ce type unique ne peut pas être déterminé, le type dominant est le type unique auquel tous les autres types du tableau peuvent se limiter. Si aucun de ces types uniques ne peut être déterminé, le type dominant est Object. Par exemple, si la liste de valeurs qui est fournie au littéral de tableau contient des valeurs de type Integer, Long et Double, le tableau résultant est de type Double. Integer et Long s'élargissent uniquement à Double. Par conséquent, Double est le type dominant. Pour plus d'informations, consultez Conversions étendues et restrictives (Visual Basic). Ces règles d'inférence s'appliquent aux types déduits pour les tableaux qui sont des variables locales définies dans un membre de classe. Bien que vous puissiez employer des littéraux de tableaux lorsque vous créez des variables au niveau de la classe, vous ne pouvez pas utiliser l'inférence de type au niveau de la classe. Par conséquent, les littéraux de tableaux spécifiés au niveau de la classe déduisent les valeurs qui sont fournies pour le littéral de tableau en tant que type Object.
Vous pouvez spécifier explicitement le type des éléments d'un tableau qui est créé à l'aide d'un littéral de tableau. Dans ce cas, les valeurs présentes dans le littéral de tableau doivent s'étendre au type des éléments du tableau. L'exemple de code suivant permet de créer un tableau de type Double à partir d'une liste d'entiers.
Dim values As Double() = {1, 2, 3, 4, 5, 6}
Littéraux de tableaux imbriqués
Vous pouvez créer un tableau multidimensionnel à l'aide des littéraux de tableaux imbriqués. Les littéraux de tableaux imbriqués doivent avoir une dimension et un nombre de dimensions, ou rang, qui est cohérent avec le tableau résultant. L'exemple de code suivant permet de créer un tableau d'entiers à deux dimensions à l'aide d'un littéral de tableau.
Dim grid = {{1, 2}, {3, 4}}
Dans l'exemple précédent, une erreur se produit si le nombre d'éléments présents dans les littéraux de tableaux imbriqués ne correspond pas. Une erreur survient également si la variable tableau a été déclarée explicitement en tant que type autre que le type à deux dimensions.
Notes
Vous pouvez éviter une erreur lorsque vous indiquez des littéraux de tableaux imbriqués de dimensions différentes en plaçant les littéraux de tableaux internes entre parenthèses.Les parenthèses forcent l'évaluation de l'expression de littéral de tableau et les valeurs résultantes sont utilisées avec le littéral de tableau externe, comme illustré dans le code suivant.
Dim values = {({1, 2}), ({3, 4, 5})}
Lorsque vous créez un tableau multidimensionnel à l'aide des littéraux de tableaux imbriqués, vous pouvez utiliser l'inférence de type. Lorsque vous employez l'inférence de type, le type déduit est le type dominant pour l'ensemble des valeurs de tous les littéraux de tableaux d'un niveau d'imbrication. L'exemple de code suivant permet de créer un tableau à deux dimensions de type Double à partir de valeurs de types Integer et Double.
Dim a = {{1, 2.0}, {3, 4}, {5, 6}, {7, 8}}
Pour obtenir d'autres exemples, consultez Comment : initialiser une variable tableau en Visual Basic.
Itération via un tableau
Lorsque vous itérez au sein d'un tableau, vous accédez à chaque élément du tableau depuis l'indice le plus bas jusqu'à l'indice le plus haut.
L'exemple suivant itère au sein d'un tableau unidimensionnel en utilisant For...Next, instruction (Visual Basic). La méthode GetUpperBound retourne la valeur la plus élevée que l'index peut avoir. La valeur d'index la plus basse est toujours 0.
Dim numbers = {10, 20, 30}
For index = 0 To numbers.GetUpperBound(0)
Debug.WriteLine(numbers(index))
Next
' Output:
' 10
' 20
' 30
L'exemple suivant itère au sein d'un tableau multidimensionnel en utilisant une instruction For...Next. La méthode GetUpperBound a un paramètre qui spécifie la dimension. GetUpperBound(0) retourne la valeur d'index la plus élevée pour la première dimension, et GetUpperBound(1) retourne la valeur d'index la plus élevée pour la deuxième dimension.
Dim numbers = {{1, 2}, {3, 4}, {5, 6}}
For index0 = 0 To numbers.GetUpperBound(0)
For index1 = 0 To numbers.GetUpperBound(1)
Debug.Write(numbers(index0, index1).ToString & " ")
Next
Debug.WriteLine("")
Next
' Output
' 1 2
' 3 4
' 5 6
L'exemple suivant itère au sein d'un tableau unidimensionnel en utilisant For Each...Next, instruction (Visual Basic).
Dim numbers = {10, 20, 30}
For Each number In numbers
Debug.WriteLine(number)
Next
' Output:
' 10
' 20
' 30
L'exemple suivant itère au sein d'un tableau multidimensionnel en utilisant une instruction For Each...Next. Toutefois, vous disposez d'un plus grand contrôle sur les éléments d'un tableau multidimensionnel si vous utilisez une instruction imbriquée For…Next, comme dans un exemple précédent, au lieu d'une instruction For Each…Next.
Dim numbers = {{1, 2}, {3, 4}, {5, 6}}
For Each number In numbers
Debug.WriteLine(number)
Next
' Output:
' 1
' 2
' 3
' 4
' 5
' 6
Tableaux comme valeurs de retour et paramètres
Pour rétablir un tableau à partir d'une procédure Function, spécifiez le type de données du tableau et le nombre de dimensions comme type de retour de la Function, instruction (Visual Basic). Dans la fonction, déclarez une variable tableau locale avec le même type de données et le même nombre de dimensions. Dans Return, instruction (Visual Basic), incluez la variable tableau locale sans parenthèses.
Pour spécifier un tableau comme paramètre pour une procédure Sub ou Function, définissez le paramètre comme tableau avec un type de données et un nombre spécifié de dimensions. Dans l'appel à la procédure, envoyez une variable tableau avec le même type de données et le même nombre de dimensions.
Dans l'exemple suivant, la fonction GetNumbers retourne Integer(). Ce type de tableau est un tableau unidimensionnel de type Integer. La procédure ShowNumbers accepte un argument Integer().
Public Sub Process()
Dim numbers As Integer() = GetNumbers()
ShowNumbers(numbers)
End Sub
Private Function GetNumbers() As Integer()
Dim numbers As Integer() = {10, 20, 30}
Return numbers
End Function
Private Sub ShowNumbers(numbers As Integer())
For index = 0 To numbers.GetUpperBound(0)
Debug.WriteLine(numbers(index) & " ")
Next
End Sub
' Output:
' 10
' 20
' 30
Dans l'exemple suivant, la fonction GetNumbersMultiDim retourne Integer(,). Ce type de tableau est un tableau bidimensionnel de type Integer. La procédure ShowNumbersMultiDim accepte un argument Integer(,).
Public Sub ProcessMultidim()
Dim numbers As Integer(,) = GetNumbersMultidim()
ShowNumbersMultidim(numbers)
End Sub
Private Function GetNumbersMultidim() As Integer(,)
Dim numbers As Integer(,) = {{1, 2}, {3, 4}, {5, 6}}
Return numbers
End Function
Private Sub ShowNumbersMultidim(numbers As Integer(,))
For index0 = 0 To numbers.GetUpperBound(0)
For index1 = 0 To numbers.GetUpperBound(1)
Debug.Write(numbers(index0, index1).ToString & " ")
Next
Debug.WriteLine("")
Next
End Sub
' Output
' 1 2
' 3 4
' 5 6
Tableaux multidimensionnels
Un tableau qui contient d'autres tableaux comme éléments est appelé un tableau de tableaux ou un tableau en escalier. Tableau en escalier et chaque élément d'un tableau en escalier peuvent avoir une ou plusieurs dimensions. La structure de données de votre application est parfois à deux dimensions, mais pas rectangulaire.
L'exemple suivant comporte un tableau des mois dont chacun des éléments est un tableau des jours. Puisque des mois distincts possèdent un nombre de jours différent, les éléments ne constituent pas un tableau rectangulaire à deux dimensions. Par conséquent, un tableau en escalier est utilisé au lieu d'un tableau multidimensionnel.
' Declare the jagged array.
' The New clause sets the array variable to a 12-element
' array. Each element is an array of Double elements.
Dim sales()() As Double = New Double(11)() {}
' Set each element of the sales array to a Double
' array of the appropriate size.
For month As Integer = 0 To 11
Dim days As Integer =
DateTime.DaysInMonth(Year(Now), month + 1)
sales(month) = New Double(days - 1) {}
Next month
' Store values in each element.
For month As Integer = 0 To 11
Dim upper = sales(month).GetUpperBound(0)
For day = 0 To upper
sales(month)(day) = (month * 100) + day
Next
Next
Tableaux de longueur zéro
Un tableau qui ne contient aucun élément est également appelé un tableau de longueur zéro. Une variable contenant un tableau de longueur zéro n'a pas la valeur Nothing. Pour créer un tableau ne comportant pas d'éléments, déclarez -1 pour l'une des dimensions du tableau, comme indiqué dans l'exemple suivant.
Dim twoDimensionalStrings(-1, 3) As String
Vous devrez peut-être créer un tableau de longueur zéro dans les circonstances suivantes :
Sans risquer une exception NullReferenceException, votre code doit accéder aux membres de la classe Array, tels que Length ou Rank, ou appeler une fonction Visual Basic telle que UBound.
Vous devez veiller à une plus grande simplification du code utilisateur sans avoir à vérifier Nothing comme un cas particulier.
Votre code interagit avec une interface de programmation d'applications (API) qui requiert que vous passiez un tableau de longueur zéro à une ou plusieurs procédures, ou qui retourne un tableau de longueur zéro d'une ou plusieurs procédures.
Taille de tableau
La taille d'un tableau est le produit des longueurs de toutes ses dimensions. Elle représente le nombre total d'éléments contenus actuellement dans le tableau.
L'exemple suivant déclare un tableau à trois dimensions.
Dim prices(3, 4, 5) As Long
La taille globale du tableau dans la variable prices est (3 + 1) x (4 + 1) x (5 + 1) = 120.
Vous pouvez rechercher la taille d'un tableau à l'aide de la propriété Length. Vous pouvez rechercher la longueur de chaque dimension d'un tableau multidimensionnel à l'aide de la méthode GetLength.
Vous pouvez redimensionner une variable tableau en lui assignant un nouvel objet tableau ou en utilisant l'instruction ReDim.
Il convient de prendre en compte les facteurs suivants.
Longueur de dimension |
L'index de chaque dimension est basé sur 0, ce qui signifie qu'il varie de 0 à sa limite supérieure. Par conséquent, la longueur d'une dimension donnée est égale à la limite supérieure déclarée pour cette dimension plus 1. |
Limites de longueurs |
La longueur de chaque dimension d'un tableau est limitée à la valeur maximale du type de données Integer, qui est (2 ^ 31) - 1. Toutefois, la taille totale d'un tableau est limitée également par la mémoire disponible sur votre système. Si vous essayez d'initialiser un tableau qui dépasse la quantité de mémoire vive disponible, le Common Language Runtime lève une exception OutOfMemoryException. |
Taille et taille d'élément |
La taille d'un tableau est indépendante du type de données de ses éléments. La taille représente toujours le nombre total d'éléments, et non le nombre d'octets de stockage qu'ils consomment. |
Consommation de mémoire |
Il n'est pas prudent de faire des suppositions quant à la manière dont un tableau est stocké en mémoire. Le stockage varie sur les plateformes de largeurs de données différentes, par conséquent le même tableau peut consommer plus de mémoire sur un système 64 bits que sur un système 32 bits. Selon configuration du système lorsque vous initialisez un tableau, le Common Language Runtime (CLR) peut assigner le stockage de façon à comprimer le plus possible les éléments ou à tous les aligner sur des limites matérielles naturelles. De plus, un tableau requiert une charge de stockage pour ses informations de contrôle et cette charge augmente avec chaque dimension ajoutée. |
Types tableau et autres types
Chaque tableau comporte un type de données, qui diffère du type de données de ses éléments. Il n'existe pas de type de données unique pour tous les tableaux. Au lieu de cela, le type de données d'un tableau est déterminé par le nombre de dimensions, ou rang, du tableau, et le type de données des éléments du tableau. Deux variables tableau sont considérées comme correspondant au même type de données uniquement si elles ont le même rang et que leurs éléments ont le même type de données. Les longueurs des dimensions d'un tableau n'influencent pas le type de données du tableau.
Chaque tableau hérite de la classe Array et vous pouvez déclarer une variable comme étant de type Array, mais vous ne pouvez pas créer de tableau de type Array. De plus, l'ReDim, instruction (Visual Basic) ne peut pas fonctionner sur une variable déclarée comme type Array. Pour ces raisons, et pour la sécurité de type, il est recommandé de déclarer chaque tableau en tant que type spécifique, tel que Integer dans l'exemple précédent.
Vous pouvez déterminer le type de données d'un tableau ou de ses éléments de plusieurs manières.
Vous pouvez appeler la méthode Object.GetType sur la variable de façon à recevoir un objet Type pour le type de la variable à l'exécution. L'objet Type contient des informations complètes dans ses propriétés et méthodes.
Vous pouvez passer la variable à la fonction TypeName pour recevoir un élément String contenant le nom du type à l'exécution.
Vous pouvez passer la variable à la fonction VarType pour recevoir une valeur VariantType représentant la classification de type de la variable.
L'exemple suivant appelle la fonction TypeName pour déterminer le type du tableau et celui de ses éléments. Le type du tableau est Integer(,) et le type de ses éléments est Integer.
Dim thisTwoDimArray(,) As Integer = New Integer(9, 9) {}
MsgBox("Type of thisTwoDimArray is " & TypeName(thisTwoDimArray))
MsgBox("Type of thisTwoDimArray(0, 0) is " & TypeName(thisTwoDimArray(0, 0)))
Les collections en tant qu'alternative aux tableaux
Les tableaux sont plus utiles pour la création et l'utilisation d'un nombre fixe d'objets fortement typés. Les collections offrent plus de souplesse pour utiliser des groupes d'objets. Contrairement aux tableaux, le groupe d'objets utilisé peut augmenter ou diminuer de façon dynamique si les besoins de l'application varient.
Si vous devez modifier la taille d'un tableau, vous devez utiliser l'ReDim, instruction (Visual Basic). Dans ce cas, Visual Basic crée un tableau et libère le tableau précédent pour qu'il soit supprimé. Cela nécessite un temps d'exécution. Par conséquent, si le nombre d'éléments avec lesquels vous travaillez change fréquemment ou si vous ne pouvez pas prévoir le nombre maximal d'éléments dont vous aurez besoin, vous pourriez obtenir des performances supérieures en utilisant une collection.
Pour certaines collections, vous pouvez assigner une clé à tout objet que vous placez dans la collection afin que vous puissiez rapidement récupérer l'objet à l'aide de la clé.
Si votre collection se limite à des éléments d'un seul type de données, vous pouvez utiliser l'une des classes de l'espace de noms System.Collections.Generic. Une collection générique met en vigueur la sécurité de type afin qu'aucun autre type de données ne puisse lui être ajouté. Lorsque vous récupérez un élément à partir d'une collection générique, il n'est pas nécessaire de déterminer son type de données ni de le convertir.
Pour plus d'informations sur les collections, consultez Collections (C# et Visual Basic).
Exemple
L'exemple suivant montre comment utiliser la classe générique List du .NET Framework pour créer une collection de listes d'objets Customer.
' Define the class for a customer.
Public Class Customer
Public Property Name As String
' Insert code for other members of customer structure.
End Class
' Create a module-level collection that can hold 200 elements.
Public CustomerList As New List(Of Customer)(200)
' Add a specified customer to the collection.
Private Sub AddNewCustomer(ByVal newCust As Customer)
' Insert code to perform validity check on newCust.
CustomerList.Add(newCust)
End Sub
' Display the list of customers in the Debug window.
Private Sub PrintCustomers()
For Each cust As Customer In CustomerList
Debug.WriteLine(cust)
Next cust
End Sub
La déclaration de la collection CustomerFile spécifie qu'elle peut contenir uniquement des éléments de type Customer. Elle prévoit également une capacité initiale de 200 éléments. La procédure AddNewCustomer vérifie que le nouvel élément est valide, puis elle l'ajoute à la collection. La procédure PrintCustomers utilise une boucle For Each pour parcourir la collection et afficher ses éléments.
Rubriques connexes
Terme |
Définition |
|---|---|
Explique le rang et les dimensions des tableaux. |
|
Décrit comment remplir des tableaux avec des valeurs initiales. |
|
Montre comment trier alphabétiquement les éléments d'un tableau. |
|
Comment : assigner un tableau à un autre tableau (Visual Basic) |
Décrit les règles et les étapes à suivre pour assigner un tableau à une autre variable de tableau. |
Aborde certains problèmes courants qui surviennent lors de l'utilisation des tableaux. |
Voir aussi
Référence
Dim, instruction (Visual Basic)