Fondamentals des tableaux en C++

Introduction

Dans ce laboratoire, vous allez apprendre les tableaux en C++. Vous allez apprendre à définir et initialiser des tableaux, et à utiliser les fonctions de tableaux.

Skills Graph

Aperçu du contenu

Les tableaux sont couramment utilisés pour stocker des données du même type. Ils sont efficaces, compacts et faciles à accéder. Combinés à une boucle, les opérations sur les éléments d'un tableau sont assez simples.

Pour créer un tableau, vous devez connaître à l'avance la longueur (ou la taille) du tableau et allouer en conséquence. Une fois qu'un tableau est créé, sa longueur est fixe et ne peut pas être modifiée.

Déclaration et utilisation des tableaux

Supposons que vous vouliez trouver la moyenne des notes d'une classe de 30 étudiants. Vous ne voulez certainement pas créer 30 variables : note1, note2,..., note30. Au lieu de cela, vous pouvez utiliser une seule variable, appelée un tableau, avec 30 éléments.

Un tableau est une liste d'éléments du même type, identifiée par une paire de crochets [ ]. Pour utiliser un tableau, vous devez déclarer le tableau avec trois choses : un nom, un type et une dimension (ou taille, ou longueur). Nous recommandons d'utiliser un nom au pluriel pour les tableaux, par exemple, notes, lignes, nombres. Par exemple :

int notes[5];        // Déclare un tableau d'entiers appelé notes avec 5 éléments
double nombres[10];  // Déclare un tableau de doubles de 10 éléments
const int TAILLE = 9;
float temps[TAILLE];  // Utilise une constante int comme longueur du tableau

// Certains compilateurs prennent en charge une variable comme longueur du tableau, par exemple :
int taille;
cout << "Entrez la longueur du tableau : ";
cin >> taille;
float valeurs[taille];

Notez que, en C++, la valeur des éléments est indéfinie après la déclaration.

Vous pouvez également initialiser le tableau lors de la déclaration avec une liste séparée par des virgules de valeurs, comme suit :

// Déclare et initialise un tableau d'entiers de 3 éléments
int nombres[3] = {11, 33, 44};
// Si la longueur est omise, le compilateur compte les éléments
int nombres[] = {11, 33, 44};
// Le nombre d'éléments dans l'initialisation doit être égal ou inférieur à la longueur
int nombres[5] = {11, 33, 44};  // Les éléments restants sont à zéro. Confusant! Ne faites pas ça
int nombres[2] = {11, 33, 44};  // ERREUR : trop d'initialiseurs

// Utilisez {0} ou {} pour initialiser tous les éléments à 0
int nombres[5] = {0};  // Premier élément à 0, les autres également à zéro
int nombres[5] = {};   // Tous les éléments à 0 également

/* Test de l'initialisation locale d'un tableau */
#include <iostream>
using namespace std;

int main() {
   int const TAILLE = 5;

   int a1[TAILLE];   // Non initialisé
   for (int i = 0; i < TAILLE; ++i) cout << a1[i] << " ";
   cout << endl;   //?????

   int a2[TAILLE] = {21, 22, 23, 24, 25}; // Tous les éléments initialisés
   for (int i = 0; i < TAILLE; ++i) cout << a2[i] << " ";
   cout << endl;   // 21 22 23 24 25

   int a3[] = {31, 32, 33, 34, 35};   // Taille déduite des valeurs d'initialisation
   int a3Taille = sizeof(a3)/sizeof(int);
   cout << "Taille est " << a3Taille << endl;   // 5
   for (int i = 0; i < a3Taille; ++i) cout << a3[i] << " ";
   cout << endl;   // 31 32 33 34 35

   int a4[TAILLE] = {41, 42};  // Les éléments initiaux sont initialisés, les autres à 0
   for (int i = 0; i < TAILLE; ++i) cout << a4[i] << " ";
   cout << endl;   // 41 42 0 0 0

   int a5[TAILLE] = {0};  // Premier élément à 0, les autres également à 0
   for (int i = 0; i < TAILLE; ++i) cout << a5[i] << " ";
   cout << endl;   // 0 0 0 0 0

   int a6[TAILLE] = {};   // Tous les éléments à 0 également
   for (int i = 0; i < TAILLE; ++i) cout << a6[i] << " ";
   cout << endl;   // 0 0 0 0 0

   for (int i=0;i<5;i++){
       // affecte une valeur à chaque élément du tableau, comme ceci
       a6[i] = i;
       cout << a6[i] << " ";
   }
}

Sortie :

6299128 0 485160213 32595 0 ## quelques valeurs inattendues
21 22 23 24 25
Taille est 5
31 32 33 34 35
41 42 0 0 0
0 0 0 0 0
0 0 0 0 0
0 1 2 3 4

Vous pouvez trouver la longueur du tableau en utilisant l'expression sizeof(nomTableau)/sizeof(nomTableau[0]), où sizeof(nomTableau) renvoie le nombre total d'octets du tableau et sizeof(nomTableau[0]) renvoie le nombre d'octets du premier élément.

Tableau et boucle

Les tableaux fonctionnent en étroite collaboration avec les boucles. Vous pouvez traiter tous les éléments d'un tableau via une boucle. C++11 introduit une boucle for basée sur une plage (ou boucle for-each) pour itérer à travers un tableau. Par exemple :

/* Test de la boucle for-each */
#include <iostream>
using namespace std;

int main() {
   int nombres[] = {11, 22, 33, 44, 55};

   // Pour chaque membre appelé nombre du tableau nombres - lecture seule
   for (int nombre : nombres) {
      cout << nombre << " ";
   }

   // Pour modifier les membres, il faut utiliser une référence (&)
   for (int &nombre : nombres) {
      nombre = 99;
   }

   for (int nombre : nombres) {
      cout << nombre << endl;
   }
   return 0;
}

Sortie :

11 22 33 44 55
99 99 99 99 99

Tableau multidimensionnel

Par exemple :

int[2][3] = { {11, 22, 33}, {44, 55, 66} };

/* Test du tableau multidimensionnel */
#include <iostream>
using namespace std;
void printArray(const int[][3], int);

int main() {
   int myArray[][3] = {{8, 2, 4}, {7, 5, 2}}; // Initialisé 2x3
                 // Seul le premier indice peut être omis et implicite
   printArray(myArray, 2);
   return 0;
}

// Affiche le contenu d'un tableau de 3 colonnes par ligne (le nombre de colonnes est fixe)
void printArray(const int array[][3], int rows) {
   for (int i = 0; i < rows; ++i) {
      for (int j = 0; j < 3; ++j) {
         cout << array[i][j] << " ";
      }
      cout << endl;
   }
}

Sortie :

8 2 4
7 5 2

Tableau de caractères

En C, une chaîne de caractères est un tableau de char terminé par un caractère NUL '\0' (code ASCII de Hex 0). C++ fournit une nouvelle classe string dans le fichier d'en-tête <string>. La chaîne de caractères originale en C est connue sous le nom de chaîne C (ou chaîne de style C ou chaîne de caractères). Vous pouvez allouer une chaîne C via :

char message[256];     // Déclare un tableau de char
                       // Peut stocker une chaîne C de jusqu'à 255 caractères terminée par '\0'
char str1[] = "Hello"; // Déclare et initialise avec un " littéral de chaîne ".
                       // La longueur du tableau est le nombre de caractères + 1 (pour '\0').
char str1char[] = {'H', 'e', 'l', 'l', 'o', '\0'};  // Identique à ci-dessus
char str2[256] = "Hello";  // La longueur du tableau est 256, en conservant une chaîne plus courte.

Pour les débutants, évitez les chaînes C. Utilisez string C++ (dans le fichier d'en-tête <string>) discuté précédemment.

Vous pouvez utiliser cin et cout pour manipuler les chaînes C.

• cin << lit une chaîne délimitée par des espaces ;
• cin.getline(*var*, *size*) lit une chaîne dans var jusqu'au caractère de nouvelle ligne, avec une longueur maximale de size-1, en éliminant le caractère de nouvelle ligne ( remplacé par '\0'). La valeur de *size* correspond généralement à la longueur du tableau de chaîne C.
• cin.get(*var*, *size*) lit une chaîne jusqu'au caractère de nouvelle ligne, mais laisse le caractère de nouvelle ligne dans le tampon d'entrée.
• cin.get(), sans argument, lit le prochain caractère.

/* Test de la chaîne C */
#include <iostream>
using namespace std;

int main() {
   char msg[256]; // Stocke une chaîne de jusqu'à 255 caractères (terminée par '\0')

   cout << "Entrez un message (avec espace)" << endl;
   cin.getline(msg, 256);  // Lit jusqu'à 255 caractères dans msg
   cout << msg << endl;

   // Accès via un tableau de caractères terminé par un caractère NUL
   for (int i = 0; msg[i]!= '\0'; ++i) {
      cout << msg[i];
   }
   cout << endl;

   cout << "Entrez un mot (sans espace)" << endl;
   cin >> msg;
   cout << msg << endl;

   // Accès via un tableau de caractères terminé par un caractère NUL
   for (int i = 0; msg[i]!= '\0'; ++i) {
      cout << msg[i];
   }
   cout << endl;
   return 0;
}

Sortie :

Entrez un message (avec espace)
hello, how are you?
hello, how are you?
hello, how are you?
Entrez un mot (sans espace)
helloworld
helloworld
helloworld

Récapitulatif

C/C++ ne réalise pas de vérification des limites d'index pour les tableaux. En d'autres termes, si l'index dépasse les limites du tableau, il n'émettra pas d'avertissement/erreur. Néanmoins, vous devez estimer la longueur et allouer une borne supérieure. C'est probablement le principal inconvénient de l'utilisation d'un tableau. C++ dispose d'une classe de modèle vector (et C++11 a ajouté une classe de modèle array), qui prend en charge les tableaux dynamiquement redimensionnables.