• Le code :
  const uint8_t BUTTON_PIN[] = {2, 5, 7, 13};
  déclare une constante de type tableau de 4 entiers non signés codés sur 8 bits chacun (uint8_t), valant respectivement 2, 5, 7 et 13. Le nombre d'éléments du tableau n'étant pas explicitement codé entre les crochets, il est implicitement déterminé par le nombre d'éléments de la liste d'expressions.
Un tel tableau permet typiquement de regrouper des numéros de broches d'entrée d'une carte à microcontrôleur pour pouvoir facilement les configurer dans une boucle for, même si ces numéros ne sont pas consécutifs.
• Le code :
  short duration[3] = {60, 5, 90};
déclare une variable de type tableau de 3 entiers courts valant respectivement 60, 5 et 90 par initialisation. Cette déclaration aurait pu aussi être codée short duration[] = {60, 5, 90};.

Un tel tableau permet par exemple de centraliser dans une même donnée les durées d'allumage des trois couleurs d'un feu de circulation. Il servira d'exemple académique récurrent pour exposer les détails syntaxiques des tableaux unidimensionnels.
• Le code :
  float temperature[24] = {0.0};
déclare une variable de type tableau de 24 décimaux (flottants simple précision), tous initialisés à la valeur 0.0.

Un tel tableau permet par exemple de réserver l'emplacement mémoire pour une série de mesure de températures horaires. Il avait servi d'exemple académique récurrent pour exposer les bases de la déclaration et de l'utilisation des tableaux dans le chapitre C2‑VI .
Attention ! Si cette déclaration était codée :
float temperature[24] = {20.0};
alors seul le premier élément du tableau serait initialisé à la valeur 20.0. Les autres éléments seraient implicitement initialisés à la valeur 0.0.
En langage C seulement, le code :
double pressure[5] = {[0] = 10.0, [1] = 20.0, [2 ... 4] = 30.0};
déclare une variable de type tableau de 5 décimaux (flottants double précision) initialisés aux valeurs :
• 10.0, 20.0 respectivement pour les deux premiers éléments ;
• 30.0 pour les trois derniers éléments.

Reprenons la déclaration du tableau de 3 éléments issu de l'exemple supra sur le thème d'un feu de circulation  :
short duration[3] = {60, 5, 90};

L'identification directe des éléments de ce tableau est très simple :

• le 1^er élément est identifié par duration[0] (valeur initiale 60) ;
• le 2^e élément est identifié par duration[1] (valeur initiale 5) ;
• le 3^e élément est identifié par duration[2] (valeur initiale 90) ;
• l'expression duration[3] identifie la valeur des deux octets de l'espace mémoire situés immédiatement après le 3^e (et dernier) élément du tableau, interprétés dans le type short.

Reprenons la déclaration du tableau de 3 éléments issu de l'exemple supra sur le thème d'un feu de circulation  :
short duration[3] = {60, 5, 90};

Il faut ne pas confondre :

• l'adresse &duration[0] de son premier élément, dont le nom de type est short * ;
• l'adresse &duration du tableau lui‑même, dont le nom de type est short(*)[3].

Comme on peut le voir sur la figure ci‑dessous, ces deux addresses ont la même valeur, elles pointent sur le même octet.

Mais ells sont de types différents, qui n'ont pas la même taille. Donc l'incrémentation unitaire de ces deux adresses ne pointent pas sur le même octet en mémoire :

• l'expression &duration[1] + 1 pointe sur le 2^e élément du tableau duration ;
• l'expression &duration + 1 pointe en dehors de l'espace mémoire allouée au tableau duration, plus précisément, sur l'octet consécutif à cet espace.

#include <stdio.h>

int main(void)
{
  short duration[3] = {60, 5, 90};
  printf("%12s %16s %16s\n", "Object",      "Address",    "Next Address");
  printf("%12s %16p %16p\n", "1st element", &duration[0], &duration[0] + 1);
  printf("%12s %16p %16p\n", "Array",       &duration,    &duration + 1);
  return 0;
}

      Object          Address     Next Address
 1st element   0x7ffcaf9fc292   0x7ffcaf9fc294
       Array   0x7ffcaf9fc292   0x7ffcaf9fc298

Reprenons la déclaration du tableau de 3 éléments issu de l'exemple académique sur le thème d'un feu de circulation  :
short duration[3] = {60, 5, 90};

Tout d'abord, après cette déclaration, hormis les éventuelles exceptions (sizeof, & – cf. supra ), l'identificateur du tableau duration fait l'objet d'une dégradation implicite en pointeur constant de donnée dont le nom de type est short *. La figure ci‑dessous récapitule les expressions de type pointeur qui ciblent le tableau et ses différents éléments.

Analysons les pointeurs formés sans l'opérateur d'adresse, qui sont représentés sur fond beige :

• sur le 1^er élément du tableau (valeur 60) :
• l'expression duration prend la même valeur que &duration[0] (une adresse) ;
• le déréférencement *duration prend donc la même valeur que duration[0] (l'entier 60) ;
• sur le 2^e élément du tableau (valeur 5) :
• l'expression duration + 1 prend la même valeur que &duration[1] (une adresse) ;
• le déréférencement *(duration + 1) prend donc la même valeur que duration[1] (l'entier 5) ;
• pour le 3^e élément du tableau (valeur 90) :
• l'expression duration + 2 prend la même valeur que &duration[2] (une adresse) ;
• le déréférencement *(duration + 2) prend donc la même valeur que duration[2] (l'entier 90).

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

int main(void)
{
  short duration[3] = {60, 5, 90};
  printf("1st element: %2d \n", *duration);
  printf("2nd element: %2d \n", *(duration + 1);
  printf("3rd element: %2d \n", *(duration + 2));
  return 0;
}

1st element: 60
2nd element:  5
3rd element: 90

Reprenons l'exemple académique précédent pour un thermostat de chauffage avec la déclaration du tableau bidimensionnel complètement initialisé :
int8_t heat[2][3] = { {22, 17, 10}, {19, 15, 5} };

Avec l'opérateur d'indexation et l'identificateur du tableau, on peut former les expressions d'identification suivantes.

• L'expression heat[0] identifie le sous‑tableau formant la 1^re ligne (j = 0) du tableau heat.
• L'expression heat[1] identifie le sous‑tableau formant la 2^e ligne (j = 1) du tableau heat.

Ces deux expressions constituent des identificateurs de sous‑tableaux (unidimensionnels) qui, rappelons‑le, sont dégradés en pointeurs constants, sauf exceptions (sizeof, &).

Quant aux éléments cellulaires de ces sous‑tableaux, ils sont identifiés par une expression de la forme heat[j][i], autrement dit tels que :

• heat[0][0] est l'élément du tableau en 1^re ligne (j = 0) et 1^re colonne (i = 0) – valeur initiale 22 ;
• heat[0][1] est l'élément du tableau en 1^re ligne (j = 0) et 2^e colonne (i = 1) – valeur initiale 17 ;
• heat[0][2] est l'élément du tableau en 1^re ligne (j = 0) et 3^e colonne (i = 2) – valeur initiale 10 ;
• heat[1][0] est l'élément du tableau en 2^e ligne (j = 1) et 1^re colonne (i = 0) – valeur initiale 19 ;
• etc.

En particulier, à titre d'exemple générique, l'expression heat[1][0] est en fait une composition de l'opérateur d'indexation appliqué à heat[0] avec l'indice 1. Sachant que le sens d'associativité de cet opérateur est de gauche à droite (→), on peut analyser cette expression comme étant de la forme (heat[1])[0] qui cible le 1^er élément ([0]) de la 2^e ligne (heat[1]) du tableau heat.

Reprenons l'exemple académique précédent pour un thermostat de chauffage avec la déclaration du tableau bidimensionnel :
int8_t heat[2][3] = { {22, 17, 10}, {19, 15, 5} };

Il faut ne pas confondre :

• l'adresse &heat[0][0] de son premier élément cellulaire est de type int8_t* ;
• l'adresse &heat[0] de sa première ligne est de type int8_t(*)[3] ;
• l'adresse &heat du tableau lui‑même est de type int8_t(*)[2][3].

Comme on peut le voir sur la figure ci‑dessous, ces deux addresses ont la même valeur, elles pointent sur le même octet.

Mais elles sont de types différents, qui n'ont pas la même taille. Donc l'incrémentation unitaire de ces deux adresses ne pointent pas sur le même octet en mémoire :

• l'expression &heat[0][0] + 1 pointe sur le 2^e élément de la première ligne ;
• l'expression &heat[0] + 1 pointe sur la 1^e élément de la 2^e ligne ;
• l'expression &heat + 1 pointe sur le premier octet en dehors de l'espace mémoire allouée au tableau duration, plus précisément, sur l'octet consécutif à cet espace (éventuellement décalé par une contrainte d'alignement – cf. chap. C3‑I ).

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

int main(void)
{
  int8_t heat[2][3] = { {22, 17, 10}, {19, 15, 5} };
  printf("%12s %16s %16s\n", "Object",      "Address",   "Next Address");
  printf("%12s %16p %16p\n", "1st element", &heat[0][0], &heat[0][0] + 1);
  printf("%12s %16p %16p\n", "1st row",     &heat[0],    &heat[0] + 1);
  printf("%12s %16p %16p\n", "Array",       &heat,       &heat + 1);
  return 0;
}

      Object          Address     Next Address
 1st element   0x7fffddcca132   0x7fffddcca133
     1st row   0x7fffddcca132   0x7fffddcca135
       Array   0x7fffddcca132   0x7fffddcca138

Reprenons l'exemple académique précédent pour un thermostat de chauffage avec la déclaration du tableau bidimensionnel :
int8_t heat[2][3] = { {22, 17, 10}, {19, 15, 5} };

Rappelons qu'il est structuré comme un tableau de 2 sous‑tableaux (des éléments de type « ligne »), identifiés respectivement par les expressions heat[0] (1^re ligne) et heat[1] (2^e ligne). Chacun de ces deux sous‑tableaux est lui‑même formé de 3 éléments, donc de taille 3 × 1 = 3 octets. On peut le vérifier en évaluant par exemple l'expression sizeof(heat[0]) : on obtient la valeur 3.

Analysons l'identification par pointeurs des éléments de la 1^religne en s'aidant de la figure ci‑dessus où les pointeurs formés sans l'opérateur d'adresse apparaissent sur fond beige :

• L'expression heat est un identificateur de tableau, donc implicitement dégradé en un pointeur sur son 1^er élément, donc elle prend la même valeur que &heat[0].
De même, dans l'expression heat[0], l'identificateur heat est implicitement dégradé en &heat[0], donc elle prend la même valeur que &heat[0][0].
• Les expressions de déréférencement **heat et *heat[0] prennent donc l'une et l'autre la valeur de heat[0][0] (valeur initiale 22 du premier élément cellulaire du tableau).

Voyons maintenant ce que produit une incrémentation de ces pointeurs :

• par dégradation implicite, l'expression heat[0] + 1 prend la même valeur que &heat[0][0] + 1, autrement dit que &heat[0][1] (adresse du 2^e élément de la ligne, qui est également le 2^e élément cellulaire du tableau) ;
• l'expression de déréférencement *(heat[0] + 1) prend donc la valeur heat[0][1] (valeur initiale 17) ;
• idem pour l'élément suivant auquel on accède par le pointeur heat[0] + 2…

Le principe est le exactement même pour la 2^e ligne lorsqu'on y accède par le pointeur heat + 1. En effet, par l'arithmétique des pointeurs, l'opération + 1 représente un saut d'adresse de la taille du type d'éléments du tableau heat, c'est‑à‑dire d'une ligne entière (on a vu supra que sizeof(heat[0]) vaut 3 octets).

Enfin, comme pour un tableau unidimensionnel (cf. supra ), l'expression &heat + 1 pointe sur l'adresse consécutive à l'espace alloué au dernier élément du tableau (et éventuellement décalée par une contrainte d'alignement spécifique à l'implémentation – cf. chap. 3‑I ).

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

int main(void)
{
  int8_t heat[2][3] = { {22, 17, 10}, {19, 15, 5} };
  printf("1st element: %2d %2d\n", **heat,         *heat[0]);
  printf("2nd element: %2d    \n", *(heat[0] + 1));
  printf("3rd element: %2d    \n", *(heat[0] + 2));
  printf("4th element: %2d %2d\n", **(heat + 1),   *(heat[1]));
  printf("2nd element: %2d    \n", *(heat[1] + 1));
  printf("3rd element: %2d    \n", *(heat[1] + 2));
  return 0;
}

1st element: 22 22
2nd element: 17    
3rd element: 10    
4th element: 19 19
2nd element: 15    
3rd element:  5