Les tableaux en C++ : Déclaration, initialisation et techniques avec pointeurs

Qu'est-ce qu'un tableau ?

En C++, un tableau est un bloc de mémoire contigu de taille fixe qui contient des éléments du même type de données. Considérez-le comme une variable unique représentant une collection de valeurs, chacune accessible par un index commençant à 0.

Les tableaux simplifient la manipulation des données en regroupant des valeurs liées, permettant un parcours efficace, un accès aléatoire et des opérations en bloc.

Pourquoi utiliser des tableaux ?

Les tableaux offrent :

• Une représentation compacte de données homogènes.
• Un accès par index en temps constant (O(1)).
• Une adaptation naturelle aux algorithmes nécessitant un traitement séquentiel ou matriciel.

Déclarer un tableau

Syntaxe :

type nomTableau[tailleTableau];

• type : Type de données C++ valide (ex. : int, double, char).
• nomTableau : Identificateur pour le tableau.
• tailleTableau : Entier positif spécifiant le nombre d'éléments.

Exemple : int age[5]; crée de l'espace pour cinq entiers.

Initialiser un tableau

Les valeurs peuvent être définies à la déclaration ou ultérieurement :

int age[5] = {19, 18, 21, 20, 17};

Laisser tailleTableau non spécifié laisse le compilateur déduire la taille :

int age[] = {19, 18, 21, 20, 17};

Les éléments individuels peuvent être assignés via l'index :

age[3] = 20; // 4ème élément

Types de tableaux

• Unidimensionnels (1D)
• Multidimensionnels (2D, 3D, …)
• Pointeurs vers tableaux

Tableau unidimensionnel

Stockage linéaire standard :

int age[5] = {19, 18, 21, 20, 17};

Exemple de parcours :

#include <iostream>
using namespace std;
int main() {
    int age[5] = {19, 18, 21, 20, 17};
    for (int i = 0; i < 5; ++i) {
        cout << age[i] << "\n";
    }
    return 0;
}

Sortie :

Tableau bidimensionnel (Matrice)

Syntaxe : type nomTableau[lignes][colonnes];

int matrice[2][3] = {{0, 2, 1}, {4, 3, 7}};

Accès : matrice[ligne][colonne]. Parcours :

#include <iostream>
using namespace std;
int main() {
    int a[3][2] = {{0, 2}, {1, 4}, {3, 7}};
    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 2; ++j) {
            cout << "a[" << i <<"] [" << j <<"] = " << a[i][j] << endl;
        }
    }
    return 0;
}

Sortie :

Tableau tridimensionnel

Illustre un cube de données :

#include <iostream>
using namespace std;
int main() {
    int a[2][3][2] = { {{4, 8}, {2, 4}, {1, 6}}, {{3, 6}, {5, 4}, {9, 3}} };
    cout << "a[0][1][0] = " << a[0][1][0] << "\n";
    cout << "a[0][1][1] = " << a[0][1][1] << "\n";
    return 0;
}

Sortie :

Pointeur vers un tableau

Un nom de tableau se convertit en pointeur vers son premier élément. Exemple :

#include <iostream>
using namespace std;
int main() {
    int age[5] = {19, 18, 21, 20, 17};
    int *p = age; // p pointe vers age[0]
    cout << "Adresse : " << p << "\n";
    cout << "Première valeur : " << *p << "\n";
    return 0;
}

Accès via arithmétique de pointeurs :

for (int i = 0; i < 5; ++i) {
    cout << "*(p + " << i <<") = " << *(p + i) << endl;
}

Accéder aux éléments

Utilisez l'opérateur d'index [ ] :

int john = age[2]; // troisième élément

Exemple complet :

#include <iostream>
using namespace std;
int main() {
    int age[5] = {19, 18, 21, 20, 17};
    int john = age[2];
    cout << "L'âge de John est : " << john;
    return 0;
}

Avantages des tableaux en C++

• Parcours séquentiel rapide.
• Accès aléatoire en O(1).
• Faible surcharge mémoire — pas d'allocation dynamique nécessaire.
• Facilite les optimisations algorithmiques (ex. : boucles cache-friendly).
• Support natif dans le langage et la bibliothèque standard.

Inconvénients des tableaux en C++

• Taille fixe — impossible de redimensionner après la déclaration.
• Risque d'erreurs hors limites si les indices sont mal gérés.
• Gaspillage mémoire si la taille déclarée dépasse l'utilisation réelle.
• Pas de vérification de limites dans les tableaux standards (utilisez std::array ou std::vector pour la sécurité).

Résumé

• Un tableau est un bloc de mémoire contigu contenant des éléments d'un seul type.
• Les indices commencent à 0 ; le dernier index est taille-1.
• Déclarez avec type nom[taille]; et initialisez avec { } ou individuellement.
• Les tableaux 1D stockent les valeurs linéairement ; les tableaux 2D et 3D modélisent matrices et tenseurs.
• Les pointeurs vers tableaux offrent un indexage flexible et un accès arithmétique.
• Choisissez les tableaux quand la taille est connue et la performance critique ; sinon préférez std::vector ou std::array.