Reprenons l'exemple académique récurrent utilisé au chapitre C5‑III  d'un tableau exprimant les durées des couleurs d'un feu tricolore.

Supposons que ces durées soient susceptibles de changer puis d'être réinitialisées à leurs valeurs initiales respectives. Il est alors rationnel de déclarer par exemple :

• un tableau constant nommé DURATION_INIT avec ces valeurs initiales,
• et un tableau variable nommé duration,

comme dans le code ci‑dessous :

const short DURATION_INIT[3] = {60, 5, 90};
short duration[3];

Malheureusement, il n'est pas possible :

• dans la déclaration, de coder l'initialisation la valeur de la variable duration avec celle de DURATION_INIT comme cela :
  short duration[3] = DURATION_INIT; // invalid statement!
• après la déclaration de duration, de coder une affectation globale comme cela :
  duration = DURATION_INIT; // invalid statement!
• ou même comme cela :
  duration = {0, 0, 0}; // invalid statement!
  et ce d'autant plus qu'on ne peut pas former une liste de constante en dehors d'une déclaration (cf. chap. C.

En effet, toutes ces instructions ne sont pas compilables puisque dans chacune, l'identificateur du tableau duration est implicitement dégradé en pointeur constant sur son premier élément (cf. chap. C5‑III ) qui ne forme pas une pas une l‑value. Il ne peut donc pas faire l'objet d'une affectation.

Reprenons l'exemple du tableau duration exprimant les durées des couleurs d'un feu tricolore.

Afin de copier les valeurs des éléments du tableau DURATION_INIT dans ceux du tableau duration, on codera une boucle for typiquement ci‑dessous :

  for (size_t k = 0; k < 3; k++) {
    duration[k] = DURATION_INIT[k];
  }

Remarques.

1. Le type size_t (cf. chap. C3‑I ) est souvent employé pour les variables d'incrémentation mais il peut très bien être remplacé par n'importe quel type entier dont l'étendue des valeurs couvre la plage d'indexation de la boucle.
2. En langage C, il est également possible d'employer un type énuméré qui permet d'améliorer la lisibilité du code. Ainsi, en prolongement de l'exemple, on peut coder l'affectation des éléments du tableau duration avec les valeurs des éléments du tableau DURATION_INIT comme ci‑dessous :

  typedef enum {GREEN, YELLOW, RED} LightColor;
  
  for (LightColor color = GREEN; color <= RED; color++) {
    duration[color] = DURATION_INIT[color];
  }

En C++, cette technique est possible mais moins commode puisqu'il faut coder une conversion explicite pour pouvoir incrémenter la variable d'itération de la boucle (cf. chap. C3‑IV ).

Reprenons l'exemple récurrent d'un tableau exprimant les durées des couleurs d'un feu tricolore, en partant de la déclaration :
short duration[3] = {60, 5, 90};

Après cette déclaration, des instructions d'affectation élémentaire qui débordent de la taille du tableau comme :
duration[-1] = 0; // out of range!
ou encore :
duration[3] = 0; // out of range!
sont compilables ! Cependant, leur effet de bord peut être dévastateur lors de l'exécution : non seulement elles peuvent écraser une autre donnée du programme mais elles peuvent aussi provoquer une erreur de segmentation (cf. chap. 5‑I ).

À titre de démonstration académique, observons le programme ci‑dessous, où l'on déclare deux variables de type tableau, respectivement duration_test et duration. Dans la fonction main, on effectue une série d'affectation sur les éléments de duration_test mais volontairement avec une petite erreur : la condition de répétition de la première boucle for est codée k <= 3 au lieu de k < 3 (cf. la ligne nº 10).

#include <stdio.h>

short duration_test[3] = {1, 1, 1};
short duration[3]      = {60, 5, 90};

int main(void) 
{
  printf("%c  %15s %6s\n", "k", "Address", "Value");
  // display addresses and modified values of array 'duration_test'
  for (size_t k = 0; k <= 3; k++){  // error: <= should be <
    duration_test[k] = k * 10;
    printf("%2zu %15p %6d", k, &duration_test[k], duration_test[k]);
    printf("%s", k == 0 ? "  duration_test\n" : "\n"); // array name
  }
  // display addresses and values of array 'duration'
  for (size_t k = 0; k < 3; k++){ 
    printf("%2zu %15p %6d", k, &duration[k], duration[k]);
    printf("%s", k == 0 ? "  duration\n" : "\n"); // array name
  }
  return 0;
}

Il en résulte que lors de l'exécution :

• L'itération k = 3 de la première boucle for écrira la valeur 30 (évaluation de k * 10) sur duration_test[3]. Or le dernier élément du tableau duration_test tel qu'il est déclaré est duration_test[2]. Donc l'écriture se fera à l'emplacement mémoire consécutif à ce dernier élément.
• Or cet emplacement sera logiquement aussi alloué à duration[0], le premier élément du tableau duration. Sa valeur 60 sera donc écrasée et remplacée par la valeur 30, comme l'illustre la figure ci‑dessous.

Pour s'en convaincre, on peut observer cet effet de bord en exécutant le programme supra avec OnlineGDB (cf. les lignes mises en orange avec une sortie standard typiquement comme ci‑dessous :

k         Address  Value
0  0x55fd44207010      0  duration_test
1  0x55fd44207012     10
2  0x55fd44207014     20
3  0x55fd44207016     30
0  0x55fd44207016     30  duration
1  0x55fd44207018      5
2  0x55fd4420701a     90

Comme prévu, la valeur 60 du premier élément du tableau duration est bel et bien écrasée par la valeur 30 via la dernière itération de la boucle d'affectation des valeurs du tableau duration_test.

Cet exemple illustre bien comment une petite erreur de codage, indétectable lors de la compilation, peut facilement engendrer un dysfonctionnement du programme (une variable est modifiée sans qu'aucune instruction du programme ne soit prévue pour cela). On retiendra donc qu'il faut être très vigilant dans la manipulation des tableaux avec l'opérateur d'indexation.

Les noms de types int8_t[2][3] et int8_t[6] désignent des tableaux de même taille mais avec structures différentes.

Le compilateur ne peut pas mettre en œuvre une conversion implicite de l'un vers l'autre, car il n'y a aucune raison de privilégier une structure plutôt que l'autre.

Considérons un exemple générique avec deux tableaux unidimensionnels déclarés de même type tab1 et tab2. Admettons qu'il comptent chacun 5 éléments, valeur qu'on peut aisément définir par une pseudo‑constante (cf. chap. C4‑III ) nommée N.

Le code ci‑dessous implémente un test d'égalité au sens où il détermine tous leurs éléments de mêmes indices sont respectivement égaux :

#include <stdio.h>
#include <stdbool.h>

#define N 5

int main(void)
{
  int tab1[N] = {1, 2, 3, 4, 5}; 
  int tab2[N] = {1, 2, 3, 4, 5}; 
  bool arrayEquality = true;
  for (size_t k = 0; k < N; k++) {
    if (tab1[k] != tab2[k]) {
      arrayEquality = false;
      break;
    }
  }
  printf("tab1 %s tab2\n", arrayEquality ? "\"==\"" : ""\"!=\"");  
  return 0;
}

Exécuté sur OnlineGDB, on obtient bien la sortie attendue :

tab1 "==" tab2

  size_t k = 0;
  while ((tab1[k] == tab2[k]) && k < N) k++;
  printf("tab1 %s tab2\n", k == N ? "\"==\"" : ""\"!=\"");  

Reprenons l'exemple académique récurrent utilisé pour un thermostat de chauffage. Pour dimensionner le tableau heat, on peut définir les deux pseudo‑constantes comme ci‑dessous :

#define NB_OF_ROWS    2
#define NB_OF_COLUMNS 3

int8_t heat[NB_OF_ROWS][NB_OF_COLUMNS] = { {22, 17, 10}, {19, 15, 5} };

On peut ensuite coder des manipulations sur ce tableau en employant les pseudo‑constantes NB_OF_ROWS et NB_OF_COLUMNS dans les conditions de répétition de boucles itératives, comme par exemple ci‑dessous (cf. les lignes n º 12 & 13) pour déterminer la valeur maximale mémorisée dans le tableau :

#include <stdio.h>
#include <stdint.h>

#define NB_OF_ROWS    2
#define NB_OF_COLUMNS 3

int8_t heat[NB_OF_ROWS][NB_OF_COLUMNS] = { {22, 17, 10}, {19, 15, 5} };

int main(void)
{	
  int8_t heatMax = 0;  // heat set point can't be negative (min. val. is 0)
  for (size_t j = 0; j < NB_OF_ROWS; j++) {
    for (size_t i = 0; i < NB_OF_COLUMNS; i++) {
      if (heat[j][i] > heatMax) {
        heatMax = heat[j][i];
      }
    }  
  }	
  printf("Max. heat value = %d °C\n", heatMax);
  return 0;
}

Reprenons le programme de l'exemple académique précédent pour rechercher la valeur maximale mémorisée dans le tableau heat de consignes d'un thermostat de chauffage.

Dans les boucles d'itération pour lire tous les éléments du tableau, à la place de pseudo‑constantes dimensionnelles, on utilise dans le programme ci‑dessous la routine proposée ci‑dessus, définie à la ligne n º 4. Les invocations de cette routine sont codées aux lignes n º 11 & 12.

#include <stdio.h>
#include <stdint.h>

#define nbOfElements(tab) (sizeof(tab)/sizeof(tab[0]))

int8_t heat[2][3] = { {22, 17, 10}, {19, 15, 5} };

int main(void)
{ 
  int8_t heatMax = 0; // heat set point can't be negative (min. val. is 0)
  for (size_t j = 0; j < nbOfElements(heat); j++) {       // nb of rows
    for (size_t i = 0; i < nbOfElements(heat[0]); i++) {  // nb of columns
      if (heat[j][i] > heatMax) {
        heatMax = heat[j][i];
      }
    }  
  } 
  printf("Max. heat value = %d °C\n", heatMax);
  return 0;
}

Les programmes proposés ci‑dessous sont des exemples académiques fonctionnels sur le thème récurrent du système de chauffage à thermostat, pour illustrer la transmission par adresse d'un argument de type tableau.

1. La fonction firstRelDiff_1 calcule la différence relative entre les deux premiers éléments d'un tableau unidimensionnel :

#include <stdio.h>
#include <stdint.h>

float firstRelDiff_1(int8_t * tab) {
  return (float) (tab[1] - tab[0]) / tab[0];
} 

int main(void)
{
  int8_t heatConfort[3] = {22, 17, 10};
  printf("%g", firstRelDiff_1(heatConfort));
  return 0;
}

Sans surprise, avec OnlineGDB, le programme est compilable et on obtient la sortie suivante, conforme à ce qui est attendu (en effet,(17 − 22)/22 ≈ −0,227) :

-0.227273

2. Supposons maintenant que l'on veuille appliquer cette fonction a un tableau bidimensionnel. Dans le programme de l'exemple précédent, on pourrait se contenter d'appeler la même fonction en prenant pour argument effectif seulement la 1^re ligne du tableau heat, c'est‑à‑dire heat[0], comme ci‑dessous :

  int8_t heat[2][3] = { {22, 17, 10}, {19, 15, 5} };
  printf("%g", firstRelDiff_1(heat[0]));

Mais on peut aussi changer le type de l'argument formel dans l'en‑tête de la fonction – autrement dit, coder une nouvelle fonction firstRelDiff_2 spécifique pour les tableaux bidimensionnels, et alors dans son appel, l'argument effectif doit être simplement l'identificateur du tableau heat, comme ci‑dessous :

float firstRelDiff_2(int8_t (* tab)[3]) {
  return (float) (tab[0][1] - tab[0][0]) / tab[0][0];
}

int main(void)
{
  int8_t heat[2][3] = { {22, 17, 10}, {19, 15, 5} };
  printf("%g", firstRelDiff_2(heat));
  return 0;
}

Dans les deux cas, une exécution sur OnlineGDB donne la même sortie attendue.

Pour illustrer ces aspects, reprenons l'exemple récurrent du système de chauffage à thermostat (cf. supra ) et codons un programme qui calcule, par l'intermédiaire d'une fonction, la moyenne des valeurs contenues dans un tableau d'éléments de type int8_t.

1. Commençons par le cas du tableau unidimensionnel heatConfort qui regroupe les 3 valeurs de consigne de chauffage en mode « confort ». On nomme meanValue_1 la fonction qui calcule, de façon générale, la moyenne des valeurs d'un tableau unidimensionnel, quel que soit son nombre d'éléments, grâce à la pseudo‑fonction nbOfElements présentée supra .

#include <stdio.h>
#include <stdint.h>

#define nbOfElements(tab) (sizeof(tab)/sizeof(tab[0]))

float meanValue_1(const int8_t * tab, size_t nbElts)
{
  int sum = 0;
  for (size_t i = 0; i < nbElts; i++) {
    sum += tab[i];
  }
  return (float) sum / nbElts;
}

int main(void)
{
  int8_t heatConfort[3] = {22, 17, 10};
  printf("%g", meanValue_1(heatConfort, nbOfElements(heatConfort)));

  return 0;
}

Dans l'en‑tête de la fonction meanValue_1 (cf. la ligne nº 6), on a bien appliqué les deux techniques exposées supra :
• le 1^er argument formel tab est déclaré avec le mot‑clef const (pointeur en « lecture seule ») car la fonction n'a pas pour but de modifier le tableau pointé ;
• on a un 2^e argument formel nbElts pour récupérer le nombre d'éléments du tableau passé comme premier argument.
Par ailleurs, la pseudo‑fonction nbOfElements est invoquée dans l'appel de la fonction meanValue_1 (cf. la ligne nº 18) pour passer en qualité de 2^e argument effectif le nombre d'éléments du tableau heatConfort qui est le 1^er argument effectif de l'appel.
Sans surprise, sur OnlineGDB, on obtient la sortie suivante, conforme aux attentes – on peut aisément vérifier que (22 + 17 + 10)/3 ≈ 16,3 :

16.3333

2. Passons maintenant au cas d'un tableau bidimensionnel. On nomme meanValue_2 l'adaptation du code de la fonction meanValue_1 à cette structure de tableau.

#include <stdio.h>
#include <stdint.h>

#define nbOfElements(tab) (sizeof(tab)/sizeof(tab[0]))

float meanValue_2(const int8_t (* tab)[3], size_t nbLines)
{
  size_t nbColumns = nbOfElements(*tab);
  int sum = 0;
  for (size_t j = 0; j < nbLines; j++) {
    for (size_t i = 0; i < nbColumns; i++) {
      sum += tab[j][i];
    }
  }
  return (float) sum / (nbLines * nbColumns);
}

int main(void)
{
  int8_t heat[2][3] = { {22, 17, 10}, {19, 15, 5} };
  printf("%g", meanValue_2(heat, nbOfElements(heat)));

  return 0;
}

Ici, on exploite la pseudo‑fonction nbOfElements :
• non seulement dans l'appel de la fonction meanValue_2 pour lui passer le nombre d'éléments du tableau, exactement comme dans l'exemple précédent (pour un tableau unidimensionnel) – sachant qu'il s'agit ici du nombre de lignes du tableau ;
• mais aussi dans le corps de la fonction pour déterminer le nombre de colonnes du tableau par déréférencement du pointeur qui est transmis comme 1^erargument de la fonction (*tab – cf. la ligne nº 6). En effet, le déréférencement d'un pointeur de tableau bidimensionnel donne un pointeur de tableau unidimensionnel.
Sans surprise, sur OnlineGDB, on obtient la sortie suivante, conforme aux attentes :

14.6667

Pour illustrer cet aspect, on peut coder toutes sortes de fonctions qui effectuent du calcul matriciel W, c'est‑à‑dire des fonctions qui font des opérations algébriques globales sur des tableaux de nombres (vecteurs, matrices).

1. Pour commencer, on peut facilement concevoir, de façon générale, une fonction qui multiplie par un coefficient un tableau unidimensionnel , qu'on nomme par exemple multiplyTab, et qui prend pour argument, dans l'ordre (cf. la figure ci‑contre) :
• le coefficient multiplicateur a,
• le tableau initial inTab,
• le tableau final outTab qui est aussi la valeur de retour de la fonction,
• le nombre d'éléments nbElts de ces deux tableaux (information indispensable, cf. supra ), lesquels ont forcément la même structure.

À titre d'application académique, une telle fonction peut trouver son utilité pour calculer de façon proportionnelle les durées d'un feu tricolore – mémorisée dans un tableau duration – à partir d'une base de valeurs préétablie, mémorisées dans un tableau durationBase. C'est ce que met en œuvre le programme suivant.

#include <stdio.h>
#include <math.h>

#define nbOfElements(tab) (sizeof(tab)/sizeof(tab[0]))

short * multiplyTab(float a, const short * inTab, short * outTab, size_t nbElts)
{
  for (size_t k = 0; k < nbElts; k++) {
    outTab[k] = round(a * inTab[k]);
  }
  return outTab;
}

int main(void)
{
  short durationBase[3] = {6, 1, 18};
  short duration[3]     = {0};
  multiplyTab(5.0, durationBase, duration, nbOfElements(duration));
  // Displaying both arrays
  for (size_t k = 0; k < nbOfElements(duration); k++) {
    printf("durationBase[%zu] = %2d   duration[%zu] = %2d\n", 
            k,    durationBase[k],    k,    duration[k]);
  }

  return 0;
}

À la lecture du code de la fonction multiplyTab (ligne nº 5 et suivantes), on peut remarquer :
• que l'argumentinTab du tableau initial est déclaré avec le mot‑clef const (cf. supra ) puisque qu'il est accédé en lecture seule par la fonction (elle n'a pas à modifier cette donnée) ;
• alors qu'au contraire, l'argument outTab du tableau final ne doit pas être déclaré en lecture seule puisque le tableau pointé est bel et bien modifié par la fonction (c'est le but puisque c'est la valeur de retour de la fonction) ;
• nbElts qui, comme usuellement, récupère le nombre d'éléments des tableaux pris en arguments .
Sans surprise, ce programme se compile et s'exécute normalement sur OnlineGDB et on obtient la sortie attendue suivante (on a bien 6 × 5 = 30, etc.) :

durationBase[0] =  6   duration[0] = 30
durationBase[1] =  1   duration[1] =  5
durationBase[2] = 18   duration[2] = 90

Remarque. Il n'échappera pas à un lecteur attentif du code qu'à la ligne nº 17, l'appel de la fonction multiplyTab ignore sa valeur de retour. On pourrait alors se demander pourquoi ne pas tout simplement coder une fonction de type void ?
Il faut cependant savoir qu'une fonction comme multiplyTab est polyvalente et qu'on peut concevoir d'autres possibilités d'appel. Par exemple, on aurait pu supprimer l'instruction de la ligne nº 17 et coder la boucle itérative d'affichage, en appliquant à l'expression d'appel de la fonction multiplyTab l'opération de sélection [k] (cf. la ligne nº 12).
  for (size_t k = 0; k < nbOfElements(duration); k++) {
    printf("durationBase[%zu] = %2d   duration[%zu] = %2d\n", 
           k,    durationBase[k],  k, 
           multiplyTab(5.0, durationBase, duration, nbOfElements(duration))[k]); 
  }
D'un point de vue syntaxique, c'est tout à fait possible puisque l'expression d'appel :
multiplyTab(5.0, durationBase, duration, nbOfElements(duration))
prend la valeur d'un pointeur de tableau, donc se comporte exactement comme un identificateur de tableau. L'opérateur de sélection vient donc tout naturellement cibler son élément d'indice k.
Cependant, une telle solution est bien moins efficace en termes de temps d'exécution, puisque toutes les valeurs du tableau de retour sont recalculées à chaque itération de la boucle for.

2. Une autre approche de la multiplication d'un tableau par un coefficient consiste à procéder avec une fonction, qu'on nommera ici multiplyTabInOut pour exprimer la particularité qu'elle emploie un seul argument formel de type pointeur de tableau, sur lequel elle produit un effet de bord voulu. Autrement dit, cet argument cumule les rôles de tableau initial et final. Les autres arguments (a et nbElts) sont inchangés.

Comme pour l'exemple précédent, on peut trouver une application académique à cette fonction dans le cadre du thème du feu tricolore pour modifier de façon proportionnelle les valeurs du tableau durationBase.

#include <stdio.h>
#include <math.h>

#define nbOfElements(tab) (sizeof(tab)/sizeof(tab[0]))

short * multiplyTabInOut(float a, short * inOutTab, size_t nbElts)
{
  for (size_t k = 0; k < nbElts; k++) {
    inOutTab[k] = round(inOutTab[k] * a);
  }
  return inOutTab;
}

int main(void)
{
  short durationBase[3] = {6, 2, 18};
  multiplyTabInOut(1.5, durationBase, nbOfElements(durationBase));
  
  printf("After multiplication:\n");
  for (size_t k = 0; k < nbOfElements(durationBase); k++) {
    printf("durationBase[%zu] = %2d\n", k, durationBase[k]);
  }

  return 0;
}

Sur OnlineGDB, on obtient la sortie attendue suivante (6 × 1,5 = 9, etc.) :

After multiplication:
durationBase[0] =  9
durationBase[1] =  3
durationBase[2] = 27

Ici, contrairement à l'exemple précédent (cf. supra ), il n'est pas question d'appeler la fonction multiplyTabInOut dans la boucle for d'affichage, sinon on effectuerait 3 fois la multiplication par le coefficient a.
En revanche, il est possible d'exploiter la valeur de retour d'une telle fonction dans le cadre d'une composition de fonctions. Par exemple, si l'on a également défini une fonction addArray pour ajouter une valeur b à tous les éléments d'un tableau comme ci‑dessous (avec la même syntaxe que multiplyTab) :
short * addTabInOut(float b, short * inOutTab, size_t nbElts)
{
  for (size_t k = 0; k < nbElts; k++) {
    inOutTab[k] += b;
  }
  return inOutTab;
}
alors l'instruction d'appel :
  addTabInOut(2.0, multiplyTabInOut(1.5, durationBase, nbOfElements(durationBase)),
                                      nbOfElements(durationBase));
ajoute 2.0 à chaque élément du tableau duration après les avoir multipliés par 1.5. Ce code est équivalent à :
  multiplyTabInOut(1.5, durationBase, nbOfElements(durationBase));
  addTabInOut(2.0, durationBase, nbOfElements(durationBase));
En termes de lisibilité, il est difficile de dire laquelle de ces deux solutions est la meilleure.

Reprenons les exemples supra  sur le thème d'un système de chauffage à thermostat. Les en‑têtes des fonctions firstRelDiff_1 et firstRelDiff_2 qui calculent la différence relative des deux premiers éléments d'un tableau de consignes de température, respectivement uni et bidimensionnel, avaient été codées initialement :

float firstRelDiff_1(int8_t * tab) 

float firstRelDiff_2(int8_t (*tab)[3])

Pour une meilleur lisibilité, il est préférable de les coder avec la syntaxe explicite, respectivement comme ci‑dessous :

float firstRelDiff_1(int8_t tab[])    // more readable

float firstRelDiff_2(int8_t tab[][3]) // more readable

En effet, on voit ainsi tout de suite que l'argument formel tab de la fonction est un tableau, unidimensionnel dans le premier cas, bidimensionnel dans le second.

Au chapitre C3‑IV , on avait présenté un exemple de déclaration d'un type énuméré, dont les constantes donnaient les valeurs (en points) des cartes à l'atout pour le jeu de la Belote :

enum Atout {
  SEPT =  0,  HUIT  =  0, 
  DAME =  3,  ROI   =  4, 
  DIX  = 10,  AS    = 11, 
  NEUF = 14,  VALET = 20
};

Toutefois, cette solution n'est pas satisfaisante car, pour gérer une partie et compter les points, il faut aussi mémoriser les valeurs des cartes des autres couleurs (non atout). Or il n'est pas possible de définir un deuxième type énuméré avec les mêmes identificateurs de noms de cartes.

Une manière de résoudre ce problème consiste par exemple à déclarer les valeurs des cartes en les structurant en deux tableaux unidimensionnels, comme ci‑dessous.

const uint8_t POINTS_COULEUR[8] = {0, 0,  0, 10,  2, 3, 4, 11};
const uint8_t POINTS_ATOUT[8]   = {0, 0, 14, 10, 20, 3, 4, 11};

De plus, pour conserver la lisibilité qu'apporte le type énuméré supra, on peut coder la déclaration complémentaire suivante :

enum Cartes {SEPT, HUIT, NEUF, DIX, VALET, DAME, ROI, AS};

où les constantes sont déclarées sans valeur explicite dans le même ordre que les valeurs des points dans les tableaux ci‑dessus. Ainsi, ces constantes énumérées SEPT, HUIT, NEUF, etc. prennent implicitement les valeurs :
0, 1, 2, etc.
qui correspondent respectivement aux numéros d'indice des valeurs de points des cartes mémorisées dans les tableaux POINTS_COULEUR et POINTS_ATOUT. Donc, l'expression :
POINTS_ATOUT[VALET]
vaut 20 conformément aux règles du jeu, et elle est bien plus lisible que :
POINTS_ATOUT[4] // less readable

typedef const uint8_t PointsCartes[8];  
PointsCartes POINTS_COULEUR = {0, 0,  0, 10,  2, 3, 4, 11};
PointsCartes POINT_ATOUT    = {0, 0, 14, 10, 20, 3, 4, 11};

const uint8_t POINTS[2][8] = { 
  {0, 0, 14, 10, 20, 3, 4, 11}, // atout
  {0, 0,  0, 10,  2, 3, 4, 11}  // couleur
};
enum Categories {ATOUT, COULEUR};
enum Cartes     {SEPT, HUIT, NEUF, DIX, VALET, DAME, ROI, AS};

Sur une carte Arduino Uno, on souhaite commander en luminosité variable une série de 4 leds de couleurs différentes (verte, jaune, orange, rouge, par exemple). Malheureusement, sur ce modèle de carte, seules les broches 35691011 disposent de la fonctionnalité PWM requise (cf. chap. C3‑VII ) ; parmi elles, il n'y a donc pas 4 broches consécutives.

Pour surmonter cette difficulté, on peut par exemple déclarer un tableau de mapping d'entrées‑sorties VAR_LED_PIN et un type énuméré VarLedColor associé, dont les constantes sont listées dans l'ordre d'indexation des couleurs des led reliées aux broches sélectionnées, comme ci‑dessous :

const uint8_t VAR_LED_PIN[4] = {3, 9, 10, 11};
enum VarLedColor : uint8_t {RED, ORANGE, YELLOW, GREEN};

On peut ensuite très efficacement coder des traitements répétitifs sur ces broches, ainsi que des actions particulières de façon très lisible, comme par exemple dans le programme de démonstration ci‑dessous, qui peut être testé sous Tinkercad :

const uint8_t VAR_LED_PIN[4] = {3, 9, 10, 11};
enum VarLedColor : uint8_t {RED, ORANGE, YELLOW, GREEN};

#define nbOfElements(tab) (sizeof(tab)/sizeof(tab[0]))

void setup()
{
  for (uint8_t k = 0; k < nbOfElements(VAR_LED_PIN); k++) {
    pinMode(VAR_LED_PIN[k], OUTPUT);
    analogWrite(VAR_LED_PIN[k], 0);
  }
}

void loop()
{
  analogWrite(VAR_LED_PIN[YELLOW], 128);
  delay(10); // only for Tinkercad simulation
}

• Dans la fonction setup, on a codé la configuration des broches par une boucle d'itérations for dont la variable d'itération k balaye tous les indices du tableau de mapping pour cibler chacune des led qu'il répertorie (cf. les lignes nº 8 à 10).
• Dans la fonction loop, on a codé l'action particulière d'allumage de la led jaune avec une luminosité intermédiaire de façon très lisible grâce à la constante énumérée YELLOW qui cible l'indice du numéro de broche de la led dans le tableau de mapping (cf. la ligne nº 16).