En C#, les tableaux servent de conteneurs pour stocker des éléments du même type de données. Lors de la création d'un tableau, il existe plusieurs approches pour l'initialiser avec des éléments. Cet article se penche sur les différentes méthodes d'initialisation des tableaux en C #, fournissant une exploration complète de chaque approche.
Méthodes pour initialiser les tableaux en C#
Les tableaux sont une structure de données essentielle dans la programmation informatique qui vous permet de stocker et de manipuler une collection d'éléments du même type de données dans des emplacements de mémoire contigus. Voici quelques façons d'initialiser des tableaux en C# :
1 : Initialisation de tableaux à l'aide de la syntaxe d'initialisation de tableau
L'approche la plus simple pour initialiser un tableau consiste à utiliser la syntaxe de l'initialiseur de tableau, car cela implique de placer les éléments du tableau entre accolades, séparés par des virgules, par exemple :
entier [ ] nombres = { 1 , 2 , 3 , 4 , 5 } ;
Dans ce code, un tableau d'entiers nommé 'numbers' est créé et initialisé avec les valeurs 1 à 5. De même, vous pouvez utiliser la même syntaxe pour initialiser un tableau multidimensionnel.
entier [ , ] monTableauMultiDimensionnel = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Voici un exemple de code qui utilise la syntaxe de l'initialiseur pour initialiser un tableau 1D et 2D en C# :
utiliser le système ;
tableau de classe
{
vide statique principal ( chaîne [ ] arguments )
{
// Initialisation d'un tableau 1D à l'aide de la syntaxe d'initialisation
entier [ ] tableau1D = { 1 , 2 , 3 , 4 , 5 } ;
Console.WriteLineConsole.WriteLine ( 'Valeurs dans array1D :' ) ;
pour ( int je = 0 ; je < array1D.Length ; je++ ) {
Console.WriteLineConsole.WriteLine ( tableau1D [ je ] ) ;
}
// Initialisation d'un tableau 2D à l'aide de la syntaxe d'initialisation
entier [ , ] tableau2D = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Console.WriteLineConsole.WriteLine ( 'Valeurs dans array2D :' ) ;
pour ( int je = 0 ; je < array2D.GetLengtharray2D.GetLength ( 0 ) ; je++ ) {
pour ( entier j = 0 ; j < array2D.GetLengtharray2D.GetLength ( 1 ) ; j++ ) {
Console.WriteLineConsole.WriteLine ( '({0}, {1}) : {2}' , je, j, tableau2D [ je, j ] ) ;
}
}
}
}
Dans ce code, nous utilisons la syntaxe d'initialisation pour initialiser un tableau d'entiers unidimensionnel appelé array1D avec les valeurs 1, 2, 3, 4 et 5.
Nous utilisons également la syntaxe d'initialisation pour initialiser un tableau d'entiers bidimensionnel appelé array2D avec les valeurs {1, 2}, {3, 4} et {5, 6}.
Nous utilisons ensuite des boucles for supplémentaires pour parcourir chaque élément de chaque tableau et imprimer sa valeur sur la console.
2 : Initialisation des tableaux à l'aide du nouveau mot-clé
Une méthode supplémentaire pour initialiser un tableau consiste à utiliser le nouveau mot-clé. Cela implique de spécifier la taille du tableau entre crochets, suivi du nouveau mot-clé, puis du type de données des éléments du tableau. Par exemple:
entier [ ] nombres = nouveau entier [ 5 ] ;
Ce code crée un tableau d'entiers nommé nombres avec une taille de 5 et initialise tous les éléments à leur valeur par défaut, qui est 0 pour les tableaux d'entiers.
Voici la syntaxe pour initialiser un tableau multidimensionnel à l'aide du nouveau mot-clé en C# :
< taper > [ , ] < arrayName > = nouveau < taper > [ < longueur1 > , < longueur2 > , ... ] { { < Valeurs initiales > } } ;
Dans cette syntaxe,
Voici un exemple d'utilisation de cette syntaxe pour initialiser un tableau d'entiers à 2 dimensions :
entier [ , ] myArray = nouveau entier [ 3 , 2 ] { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Dans cet exemple, nous initialisons un tableau d'entiers 2d appelé myArray avec 3 lignes et 2 colonnes à l'aide du nouveau mot-clé. Nous fournissons également des valeurs initiales pour chaque élément du tableau en utilisant la syntaxe des accolades doubles. Les valeurs sont {1, 2}, {3, 4} et {5, 6}, correspondant aux éléments de chaque ligne.
Voici un exemple d'utilisation du mot clé new pour initialiser à la fois un tableau unidimensionnel et un tableau bidimensionnel en C#, ainsi que du code pour imprimer les valeurs dans chaque tableau :
utiliser le système ;tableau de classe
{
vide statique principal ( chaîne [ ] arguments )
{
// Initialisation d'un 1 -tableau dimensionnel
entier [ ] myArray1D = nouvel entier [ ] { 1 , 2 , 3 , 4 , 5 } ;
Console.WriteLineConsole.WriteLine ( 'Valeurs dans myArray1D :' ) ;
pour ( int je = 0 ; je < myArray1D.Length ; je++ )
{
Console.WriteLineConsole.WriteLine ( myArray1D [ je ] ) ;
}
// Initialisation d'un 2 -tableau dimensionnel
entier [ , ] myArray2D = nouvel entier [ , ] { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Console.WriteLineConsole.WriteLine ( 'Valeurs dans myArray2D :' ) ;
pour ( int je = 0 ; je < myArray2D.GetLength ( 0 ) ; je++ )
{
pour ( entier j = 0 ; j < myArray2D.GetLength ( 1 ) ; j++ )
{
Console.WriteLineConsole.WriteLine ( '({0}, {1}) : {2}' , je, j, monTableau2D [ je, j ] ) ;
}
}
}
}
Dans ce code, nous utilisons le nouveau mot-clé pour initialiser un tableau d'entiers unidimensionnel appelé myArray1D avec les valeurs 1, 2, 3, 4 et 5, et un tableau d'entiers à 2 dimensions appelé myArray2D avec les valeurs {1, 2}, {3, 4} et {5, 6}.
Nous utilisons ensuite des boucles for pour parcourir chaque élément de chaque tableau et imprimer sa valeur sur la console. Notez que pour le tableau à 2 dimensions, nous utilisons ObtenirLongueur() pour déterminer le nombre de lignes et de colonnes, et en utilisant des boucles for imbriquées pour parcourir chaque élément.
3 : Initialisation des tableaux à l'aide de boucles
Les tableaux peuvent également être initialisés à l'aide de boucles. Une approche consiste à utiliser une boucle for, qui vous permet de parcourir le tableau et d'attribuer des valeurs à chaque élément.
entier [ ] nombres = nouveau entier [ 5 ] ;pour ( int je = 0 ; je < nombres.Longueur ; je++ )
{
Nombres [ je ] = je + 1 ;
}
Ce code crée un tableau d'entiers nommé nombres avec une taille de 5 et attribue à chaque élément une valeur égale à son index plus 1. Voici un exemple d'initialisation d'un tableau d'entiers à 2 dimensions en C# à l'aide de boucles :
pour ( int je = 0 ; je < 3 ; je++ )
{
pour ( entier j = 0 ; j < 2 ; j++ )
{
monTableau [ je, j ] = je + j;
}
}
Dans cet exemple, nous utilisons des boucles for imbriquées pour parcourir chaque élément d'un tableau d'entiers à 2 dimensions appelé monTableau , qui comporte 3 lignes et 2 colonnes. Pour chaque élément, nous définissons sa valeur sur la somme de ses indices de ligne et de colonne en utilisant l'expression i + j.
Voici un exemple d'utilisation de boucles pour initialiser à la fois un tableau unidimensionnel et un tableau bidimensionnel en C#, ainsi que du code pour imprimer les valeurs dans chaque tableau :
utiliser le système ;tableau de classe
{
vide statique principal ( chaîne [ ] arguments )
{
// Initialisation d'un 1 -tableau dimensionnel utilisant une boucle
entier [ ] myArray1D = nouvel entier [ 5 ] ;
pour ( int je = 0 ; je < myArray1D.Length ; je++ )
{
myArray1D [ je ] = je + 1 ;
}
Console.WriteLineConsole.WriteLine ( 'Valeurs dans myArray1D :' ) ;
pour ( int je = 0 ; je < myArray1D.Length ; je++ )
{
Console.WriteLineConsole.WriteLine ( myArray1D [ je ] ) ;
}
// Initialisation d'un 2 -tableau dimensionnel utilisant des boucles imbriquées
entier [ , ] myArray2D = nouvel entier [ 3 , 2 ] ;
pour ( int je = 0 ; je < 3 ; je++ )
{
pour ( entier j = 0 ; j < 2 ; j++ )
{
myArray2D [ je, j ] = je + j;
}
}
Console.WriteLineConsole.WriteLine ( 'Valeurs dans myArray2D :' ) ;
pour ( int je = 0 ; je < 3 ; je++ )
{
pour ( entier j = 0 ; j < 2 ; j++ )
{
Console.WriteLineConsole.WriteLine ( '({0}, {1}) : {2}' , je, j, monTableau2D [ je, j ] ) ;
}
}
}
}
Dans ce code, nous utilisons une boucle for pour initialiser un tableau d'entiers à 1 dimension appelé myArray1D avec les valeurs 1, 2, 3, 4 et 5. Nous utilisons également des boucles for imbriquées pour initialiser un tableau d'entiers à 2 dimensions appelé myArray2D avec les valeurs {0, 1}, {1, 2} et {2, 3} en utilisant l'expression i + j.
Ensuite, utilisez des boucles for supplémentaires pour parcourir chaque élément de chaque tableau et imprimez sa valeur sur la console.
4 : Initialisation des tableaux à l'aide de Array.Copy()
Une approche alternative à l'initialisation d'un tableau consiste à utiliser la fonction Array.Copy(). Cela implique de créer un tableau source avec les éléments souhaités, puis de les copier dans un tableau cible. Par exemple:
entier [ ] source = { 1 , 2 , 3 , 4 , 5 } ;entier [ ] cible = nouvel entier [ source.Length ] ;
Tableau.Copier ( source , cible, source.Longueur ) ;
Ce code crée un tableau d'entiers nommé source avec les valeurs 1 à 5, crée un nouveau tableau d'entiers nommé cible avec la même taille que source, puis copie les éléments de la source vers la cible.
Permettez-moi de présenter un exemple démontrant l'utilisation de Array.Copy pour initialiser un tableau d'entiers à deux dimensions en C# :
entier [ , ] tableausource = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;entier [ , ] destinationArray = nouveau entier [ 3 , 2 ] ;
Tableau.Copier ( sourceArray, destinationArray, sourceArray.Length ) ;
Dans cet exemple, nous avons un tableau d'entiers à 2 dimensions appelé sourceTableau avec 3 lignes et 2 colonnes. Nous utilisons Tableau.Copier() pour copier le contenu de sourceArray dans un nouveau tableau d'entiers à 2 dimensions appelé destinationArray, qui a également 3 lignes et 2 colonnes.
Le Tableau.Copier() la méthode prend trois arguments : le tableau source , le tableau de destination , et le longueur des données à copier. Dans ce cas, nous copions tout le contenu de sourceTableau dans destinationTableau , donc on passe sourceArray.LengthsourceArray.Length comme troisième argument.
Notez que vous pouvez utiliser Tableau.Copier() pour initialiser des tableaux avec n'importe quel nombre de dimensions, tant que les tableaux source et de destination ont le même nombre de dimensions et la même taille dans chaque dimension.
Aussi, gardez à l'esprit que Tableau.Copier() effectue une copie superficielle du tableau source, ce qui signifie que si le tableau source contient des types de référence, les références seront copiées mais les objets eux-mêmes ne seront pas dupliqués.
Voici le code complet qui utilise Tableau.Copier() fonction pour initialiser le tableau en C# :
utiliser le système ;tableau de classe
{
vide statique principal ( chaîne [ ] arguments )
{
// Initialisation d'un 1 -tableau dimensionnel utilisant Array.Copy
entier [ ] tableausource1D = { 1 , 2 , 3 , 4 , 5 } ;
entier [ ] destinationArray1D = nouvel entier [ 5 ] ;
Tableau.Copier ( sourceArray1D, destinationArray1D, sourceArray1D.Length ) ;
Console.WriteLineConsole.WriteLine ( 'Valeurs dans destinationArray1D :' ) ;
pour ( int je = 0 ; je < destinationArray1D.Length ; je++ ) {
Console.WriteLineConsole.WriteLine ( destinationTableau1D [ je ] ) ;
}
// Initialisation d'un 2 -tableau dimensionnel utilisant Array.Copy
entier [ , ] tableausource2D = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
entier [ , ] destinationArray2D = nouvel entier [ 3 , 2 ] ;
Tableau.Copier ( sourceTableau2D, destinationTableau2D, sourceTableau2D.Longueur ) ;
Console.WriteLineConsole.WriteLine ( 'Valeurs dans destinationArray2D :' ) ;
pour ( int je = 0 ; je < destinationArray2D.GetLength ( 0 ) ; je++ ) {
pour ( entier j = 0 ; j < destinationArray2D.GetLength ( 1 ) ; j++ ) {
Console.WriteLineConsole.WriteLine ( '({0}, {1}) : {2}' , je, j, destinationTableau2D [ je, j ] ) ;
}
}
}
}
Dans ce code, nous utilisons Tableau.Copier() pour initialiser un tableau d'entiers unidimensionnel appelé destinationArray1D avec les valeurs 1, 2, 3, 4 et 5 à partir d'un tableau source appelé sourceArray1D.
Nous utilisons également Tableau.Copier() pour initialiser un tableau d'entiers bidimensionnel appelé destinationArray2D avec les valeurs {1, 2}, {3, 4} et {5, 6} à partir d'un tableau source appelé sourceArray2D.
Nous utilisons ensuite des boucles for supplémentaires pour parcourir chaque élément de chaque tableau et afficher sa valeur sur la console.
Conclusion
Dans cet article, nous avons exploré différentes façons d'initialiser des tableaux en C#. Nous avons couvert la syntaxe de l'initialiseur de tableau, en utilisant le nouveau mot-clé, en initialisant les tableaux à l'aide de boucles et en utilisant la méthode Array.Copy(). Selon le cas d'utilisation spécifique, chacune de ces méthodes possède son propre ensemble d'avantages et d'inconvénients. En vous familiarisant avec ces diverses approches, vous pourrez choisir celle qui convient le mieux à vos besoins particuliers.