Les tableaux à 1 dimension

"Un tableau à 1 dimension, c’est comme une rangée d’étagères numérotées."

Un développeur bien rangé

Qu’est-ce qu’un tableau à 1 dimension ?

Un tableau à 1 dimension est une structure qui permet de stocker plusieurs éléments du même type, dans un ordre précis, sous un seul nom de variable.

Chaque valeur est accessible via un indice (ou position), qui commence à 0.

Déclaration et initialisation

Pour déclarer un tableau en C#, il faut utiliser la syntaxe « [] » associée à un type.
Il faudra aussi allouer l’espace mémoire nécessaire pour le tableau avant de l’utiliser.
Ces deux opérations peuvent se faire en écrivant une ligne
(dans l’exemple, je crée un tableau d’entiers (int) ):

Prener l'habitude de mettre vos noms de variables de type tableau au pluriel !.

// Déclaration d’un tableau vide de 5 entiers
int[] numbers = new int[5];

// Initialisation directe
string[] fruits = { "Pomme", "Banane", "Cerise" };

// Accès à un élément
Console.WriteLine(fruits[1]);  // Affiche "Banane"

Lorsque vous déclarez un tableau, les crochets ([]) doivent suivre le type, et non l'identificateur. La présence de crochets après l'identificateur ne correspond pas à une syntaxe conforme en C#.

Initialisation directe d’un tableau

// Initialisation directe
string[] fruits = { "Pomme", "Banane", "Cerise" };

Cette ligne crée un tableau de chaînes de caractères (string[]) nommé fruits, contenant directement 3 éléments : "Pomme", "Banane" et "Cerise".

Pourquoi n’y a-t-il pas de new ici ?

En C#, on peut écrire une version complète de cette initialisation :

string[] fruits = new string[] { "Pomme", "Banane", "Cerise" };

Cela fonctionne parfaitement.

Mais comme on fournit immédiatement les valeurs, le compilateur comprend automatiquement :

Le type (string)
Le nombre d’éléments (ici, 3)

Il est donc possible de simplifier l’écriture :

string[] fruits = { "Pomme", "Banane", "Cerise" };

Cette forme est appelée initialisation implicite.

À retenir

Lorsqu’on déclare et initialise un tableau en même temps, on peut omettre le new : C# comprend tout seul de quoi il s'agit.

Comparaison

Avec `new` (forme complète)	Sans `new` (forme courte)
`string[] fruits = new string[] { "Pomme", ... };`	`string[] fruits = { "Pomme", ... };`
Plus détaillée, plus longue	Plus rapide à écrire
Obligatoire si on initialise plus tard	Pratique si on connaît toutes les valeurs

Astuce pédagogique

C’est comme si tu créais une boîte et la remplissais tout de suite :
➡️ Pas besoin de dire "je veux une boîte de 3 places", car tu montres directement ce qu’il y a dedans.

Autre exemple

  // déclaration d'un tableau d'entier sans dimension
  int[] tabNumbers;   

  tabNumbers = new int[10];  // tableau d'entier à 10 éléments
  tabNumbers = new int[20];  // tableau d'entier à 20 éléments

Parcours d’un tableau

➤ Avec une boucle `for`

On peut parcourir un tableau en C# avec une boucle for.
Voici un exemple avec le tableau de fruits :

string[] fruits = { "Pomme", "Banane", "Cerise" };

for (int i = 0; i < fruits.Length; i++)
{
    Console.WriteLine(fruits[i]);
}

Que fait cette boucle ?

Elle commence à l’index 0 (premier fruit).
Elle s’arrête quand i atteint fruits.Length (le nombre d’éléments).
À chaque tour, elle affiche l’élément à la position i.

Détail du déroulement

i (index)	fruits[i]	Affichage
0	"Pomme"	Pomme
1	"Banane"	Banane
2	"Cerise"	Cerise

Pourquoi utiliser une boucle `for` ?

Tu peux suivre l’index (utile pour numéroter ou modifier).
Tu as un contrôle total sur le début, la fin, et les étapes.

➤ Avec une boucle `foreach`

La boucle foreach permet de parcourir tous les éléments d’un tableau sans gérer les index manuellement :

string[] fruits = { "Pomme", "Banane", "Cerise" };

foreach (string fruit in fruits)
{
    Console.WriteLine(fruit);
}

Explication

fruit est une variable temporaire qui contient chaque élément du tableau, un par un.
À chaque passage, fruit prend successivement la valeur :
"Pomme"
"Banane"
"Cerise"
La boucle s'arrête automatiquement à la fin du tableau.

Avantages de `foreach`

Très simple et lisible
Moins d'erreurs possibles
Idéal quand on lit un tableau, sans vouloir le modifier ou accéder à l'index

À savoir

La boucle foreach ne donne pas accès à l’index des éléments.
Si tu dois connaître leur position (0, 1, 2...), il vaut mieux utiliser une boucle for.

Modifier ou lire un élément

nombres[0] = 12;           // Affecter une valeur
int x = nombres[0];        // Lire une valeur

Longueur du tableau

Utilisez .Length pour connaître le nombre d’éléments.

Console.WriteLine("Taille : " + nombres.Length);

⚠️ Erreurs fréquentes

❌ Accès hors limites : fruits[3] alors qu’il n’y a que 3 éléments (indice max = 2) ➜ IndexOutOfRangeException
❌ Confondre taille et indices : un tableau de taille 5 a des indices de 0 à 4
❌ Ne pas initialiser le tableau ➜ erreur à l’utilisation

Opérations utiles avec un tableau

En C#, un tableau (string[], int[], etc.) propose plusieurs propriétés et méthodes pour interagir avec les données facilement.

Exemple de base

int[] nombres = { 4, 9, 2, 7, 5 };

Propriétés et méthodes utiles

🔸 Length - Donne le nombre total d’éléments du tableau.

int taille = nombres.Length;

🔸 Array.Sort(...) - Trie le tableau en ordre croissant.

Array.Sort(nombres);

🔸 Array.Reverse(...) - Inverse l’ordre des éléments.

Array.Reverse(nombres);

🔸 nombres.Max() et nombres.Min() - Renvoie le plus grand ou le plus petit élément.

int max = nombres.Max();
int min = nombres.Min();

🔸 nombres.Sum() - Calcule la somme de tous les éléments.

int total = nombres.Sum();

🔸 nombres.Contains(valeur) - Vérifie si une valeur est présente dans le tableau.

bool existe = nombres.Contains(7);

🔸 nombres.Count(...) ou LongCount(...) - Permet de compter avec une condition (LINQ nécessaire).

int pairs = nombres.Count(n => n % 2 == 0); // compte les nombres pairs

Tableau récapitulatif

Propriété / Méthode	Utilité	Exemple
`.Length`	Nombre d’éléments	`nombres.Length`
`Array.Sort()`	Trie le tableau	`Array.Sort(nombres)`
`Array.Reverse()`	Inverse l’ordre	`Array.Reverse(nombres)`
`.Max()`	Plus grande valeur	`nombres.Max()`
`.Min()`	Plus petite valeur	`nombres.Min()`
`.Sum()`	Somme des éléments	`nombres.Sum()`
`.Contains(x)`	Vérifie si une valeur est présente	`nombres.Contains(7)`
`.Count(...)`	Compte selon une condition	`nombres.Count(n => n % 2 == 0)`
`.LongCount(...)`	Idem mais pour de très grands tableaux	`nombres.LongCount()`

💡 Les méthodes comme Max(), Count(), Sum()... nécessitent l’espace de noms :
using System.Linq;

✅ Exemple combiné

int[] notes = { 14, 8, 16, 12, 7 };

Console.WriteLine("Max : " + notes.Max());
Console.WriteLine("Min : " + notes.Min());
Console.WriteLine("Somme : " + notes.Sum());
Console.WriteLine("Nombre de notes >= 10 : " + notes.Count(n => n >= 10));

Autres exemples

Quiz

Testez vos connaissances ! 📝 Clique sur chaque question pour découvrir la réponse.

1️⃣ Quel est l’indice du dernier élément d’un tableau de 5 éléments ?

A. 5
B. 4
C. 1
D. 0
E. 6

✅ Afficher la réponse

Réponse B: Les indices vont de 0 à taille-1, donc ici de 0 à 4.

2️⃣ Que se passe-t-il si on essaie d’accéder à un indice inexistant ?

A. L’élément retourné vaut null
B. Le programme renvoie 0
C. Une erreur de compilation
D. Une exception IndexOutOfRangeException est levée
E. Rien ne se passe

✅ Afficher la réponse

Réponse D: Une tentative d’accès hors limite lève une exception IndexOutOfRangeException.

3️⃣ Quelle propriété permet de connaître la taille d’un tableau ?

A. Count
B. Size
C. Length
D. Max
E. Index

✅ Afficher la réponse

Réponse C: Length retourne le nombre total d’éléments dans le tableau.

4️⃣ Quel type de boucle est le plus simple pour parcourir tous les éléments d’un tableau ?

A. for
B. foreach
C. while
D. switch
E. if

✅ Afficher la réponse

Réponse B: foreach est spécialement conçu pour parcourir tous les éléments sans se soucier des indices.

5️⃣ Quelle est la bonne déclaration pour un tableau de 10 entiers ?

A. int tableau[10];
B. int[] tableau = new int[10];
C. int tableau = [10];
D. array tableau = int[10];
E. int tableau = new array[10];

✅ Afficher la réponse

Réponse B: La bonne syntaxe est int[] tableau = new int[10];

Pour aller plus loin

Documentation OfficielleGuides et tutoriels

Documentation Microsoft – Tableaux en C#
Guide complet sur les tableaux : 1D, multidimensionnels, et méthodes associées.

W3Schools – C# Arrays
Présentation claire avec exemples interactifs pour comprendre les tableaux.
Programiz – C# Arrays
Couvre les bases avec des illustrations de syntaxe, accès et manipulation.
Dot Net Tutorials – Arrays in C#
Articles pédagogiques pour comprendre et manipuler efficacement les tableaux.

Navigation

Introduction Tableaux à 1 dimension Tableaux à 2 dimensions Travail pratique