Tableau brut

Un tableau brut est plus un substrat organisationnel qu'une structure de données à proprement dit. Nous entendons ici par tableau brut la définition qu'en donnent les langages C et C++, soit celle d'une séquence contiguë en mémoire d'éléments du même type.

Passer un tableau brut par valeur à une fonction, en C ou en C++, provoque un phénomène nommé décrépitude de pointeurs (Pointer Decay en anglais), par lequel le concept de tableau se perd et la fonction appelée ne voit plus qu'un pointeur sur le premier élément. Pour que l'information quant à la taille d'un tableau soit préservée lors d'un appel de fonction, il faut que ce tableau soit passé par référence.

Opérations clés

Un tableau brut n'offre pas d'opérations à proprement parler, du moins en C ou en C++, outre l'accès à un membre par son indice, et cette opération se fait en temps constant (complexité ). Sa taille est fixe une fois construit, donc les concepts d'insertion ou de suppression d'un élément n'y ont pas de sens structurel en soi. Il est par contre possible d'exposer une gamme de services pour des tableaux bruts sans effort important.

Opération Explications Exemples

Déduire la taille (localement)

Il est d'usage courant d'initialiser un tableau avec une séquence de valeurs sans spécifier explicitement la taille de ce tableau. Ceci permet au tableau de s'adapter au nombre de valeurs utilisées lors de son initialisation, ce qui peut faciliter l'écriture de code de tests par exemple.

Si toutefois il semble utile dans le programme d'évaluer cette taille suite à l'initialisation du tableau, ce calcul peut se faire à la compilation sur la base d'arithmétique simple, c'est-à-dire en divisant la taille du tableau entier par celle de l'un de ses éléments.

 
int main() {
   int vals[] = { 2,3,5,7,11 };
   enum { N = sizeof(vals) / sizeof(vals[0]) };
   // ...
}
Déduire la taille (fonction)

Lorsque la taille d'un tableau peut être déduite du contexte d'appel (donc pas lorsque le tableau a été alloué dynamiquement ou lorsque la décrépitude de pointeurs y a été appliquée) en écrivant une fonction mettant en valeur cette taille, comme dans l'exemple proposé à droite.

 
#include <iostream>
template <class T, `std::size_t N>
   constexpr std::size_t taille(const T(&arr)[N]) {
      return N;
   }
int main() {
   using namespace std;
   int tab0[10] = { 1,2,3,4,5,6 }; // suivi de quatre zéros dû à la taille
   int tab1[] = { 2,3,5,7,11 };
   cout << taille(tab0) << endl; // 10
   cout << taille(tab1) << endl; // 5
}
Déduire des itérateurs sur les extrémités

Dans <algorithm>, un en-tête standard important de C++, se trouvent des fonctions std::begin() et std::end() respectivement capables de déterminer un itérateur sur le début et un itérateur sur la fin d'un tableau brut pour lequel le contexte d'appel contient l'information suffisante en ce sens.

Des versions simplistes de ces services, appelées debut() et fin(), apparaissent à droite. Notez que ces fonctions s'expriment en versions const et non-const. Elles vous sont présentées à titre illustratif; en pratique, utilisez les versions standards.

Notez au passage qu'il aurait été possible d'exprimer taille() comme suit :

template <class T, std::size_t N>
   std::size_t taille(const T(&arr)[N]) {
      return fin(arr) - debut(arr);
   }
 
template <class T, std::size_t N>
   constexpr T* debut(T (&arr)[N]) {
      return &arr[0]; // ou arr + 0, au choix
   }
template <class T, std::size_t N>
   constexpr const T* debut(const T (&arr)[N]) {
      return &arr[0]; // ou arr + 0, au choix
   }
template <class T, std::size_t N>
   constexpr T* fin(T (&arr)[N]) {
      return &arr[N]; // ou arr + N, au choix
   }
template <class T, std::size_t N>
   constexpr const T* fin(const T (&arr)[N]) {
      return &arr[N]; // ou arr + 0, au choix
   }

Pédagogie :

Lectures complémentaires

Valid XHTML 1.0 Transitional

CSS Valide !