C++ Academy · Leçon

std::array de taille fixe

Une alternative sûre aux tableaux C

std::array de taille fixe est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C++ Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C++ Academy comprend 4 leçons au total.

Un tableau C sûr

std::array<T, N> est un tableau de taille fixe qui connaît sa propre taille et se comporte comme un véritable conteneur. Incluez <array>.

#include <iostream>
#include <array>
int main() {
    std::array<int, 3> a = {1, 2, 3};
    std::cout << a[0] << " " << a.size() << "\n";
}

Connaît sa taille

Contrairement à un tableau brut qui se convertit implicitement en pointeur, std::array indique toujours sa longueur via size().

#include <iostream>
#include <array>
int main() {
    std::array<double, 4> a{};
    std::cout << a.size() << "\n"; // 4
}

Boucle for basée sur une plage

Puisqu'il s'agit d'un véritable conteneur, vous pouvez le parcourir avec une boucle for basée sur une plage.

#include <iostream>
#include <array>
int main() {
    std::array<int, 3> a = {10, 20, 30};
    for (int x : a) std::cout << x << " ";
    std::cout << "\n";
}

at() avec vérification des limites

at(i) lève std::out_of_range lorsqu'un indice est incorrect, tandis que operator[] n'effectue aucune vérification : choisissez selon vos besoins en matière de sécurité.

#include <iostream>
#include <array>
int main() {
    std::array<int, 2> a = {1, 2};
    try { a.at(5); }
    catch (const std::out_of_range&) { std::cout << "out of range\n"; }
}

front, back et data

Accesseurs pratiques : front() et back() renvoient les premier et dernier éléments ; data() fournit un pointeur brut pour les API C.

#include <iostream>
#include <array>
int main() {
    std::array<int, 3> a = {7, 8, 9};
    std::cout << a.front() << " " << a.back() << "\n";
}

Copiable par valeur

std::array se copie simplement avec =, en copiant chaque élément, contrairement aux tableaux bruts qui se convertissent en pointeurs.

#include <iostream>
#include <array>
int main() {
    std::array<int, 3> a = {1, 2, 3};
    std::array<int, 3> b = a; // full copy
    b[0] = 99;
    std::cout << a[0] << " " << b[0] << "\n"; // 1 99
}

Fonctionne avec les algorithmes

Les algorithmes standard acceptent les itérateurs de std::array ; ici, nous le trions.

#include <iostream>
#include <array>
#include <algorithm>
int main() {
    std::array<int, 4> a = {4, 1, 3, 2};
    std::sort(a.begin(), a.end());
    for (int x : a) std::cout << x << " ";
    std::cout << "\n";
}

fill et comparaison

fill(value) définit chaque élément ; std::array prend également en charge la comparaison élément par élément avec ==.

#include <iostream>
#include <array>
int main() {
    std::array<int, 3> a{};
    a.fill(5);
    std::array<int, 3> b = {5, 5, 5};
    std::cout << (a == b) << "\n"; // 1
}

La taille fait partie du type

La longueur N est intégrée au type : une fonction prenant std::array<int,3> n'acceptera donc pas un tableau de taille 4. C'est là que std::span sera utile par la suite.

Allocation sur la pile

std::array stocke ses éléments directement dans l'objet (généralement sur la pile), sans allocation sur le tas, ce qui le rend rapide et prévisible pour les données de taille fixe.

Tableau et vecteur

Utilisez std::array lorsque la taille est connue à la compilation et fixe. Utilisez std::vector lorsque la taille peut changer à l'exécution.

Vérification rapide

Vérifiez votre compréhension de std::array.

Récapitulatif

Vous avez appris à utiliser std::array :

Conteneur de taille fixe, conscient de sa taille, sans allocation sur le tas.
at() vérifie les limites ; [] ne les vérifie pas.
Copiable, comparable et compatible avec les algorithmes.
La taille N fait partie du type.

Questions Fréquemment Posées

La leçon « std::array de taille fixe » est-elle gratuite ?

Oui — le texte complet de « std::array de taille fixe » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C++ Academy, passe à CoddyKit PRO. Le cours C++ Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « std::array de taille fixe » ?

Une alternative sûre aux tableaux C Tu pratiques C++ Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C++ Academy ?

Aucune expérience préalable n'est requise. C++ Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « std::array de taille fixe » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C++ Academy ?

Oui. Chaque leçon C++ Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à C++ Academy