1. Pour caractériser de façon simplifiée un résistor par ses bandes de couleur normalisées (norme CEI 60757 W), on peut coder la déclaration d'un tableau de 4 entiers comme ci‑dessous :
   int stripes_R[4] = {1, 0, 2, 5}; // brown, black, red, gold
   chaque élément du tableau représentant la valeur numérique associée à la couleur de la bande correspondante – noir 0, marron 1, rouge 2, orange 3 etc.
Remarque. On verra au chapitre C3‑IV  qu'il serait possible de rendre ce code plus lisible en déclarant un type énuméré pour les valeurs des couleurs.

2. Pour stocker un relevé annuel de températures moyennes mensuelles, on peut par exemple coder la déclaration d'un tableau de 12 décimaux comme ci‑dessous :
   float monthlyTemp_C[12] = {0.0};
   sachant qu'ici, les éléments du tableau sont tous initialisés à zéro.
Remarque. Il aurait été possible de leur affecter une valeur distincte à chacun par le biais d'une vraie liste comme dans l'exemple précédent, mais ce n'est pas forcément indispensable si ces valeurs vont faire l'objet d'une affectation au cours de l'exécution du programme (typiquement, par la lecture d'une ressource sur l'Internet).

1. Pour programmer sur ordinateur un jeu de puissance 4 W, on peut coder la déclaration d'un tableau bidimensionnel de 6 × 7 entiers – en fait, 6 lignes de 7 colonnes chacune – par l'instruction suivante :
   int board[6][7] = {0};
   sachant que chaque cellule du tableau est destiné à valoir respectivement 0, 1 ou 2 selon que l'emplacement correspondant est vide ou contient un jeton du joueur « 1 » ou « 2 ».

2. Pour stocker un relevé décennal de températures moyennes mensuelles, on peut par exemple coder la déclaration d'un tableau bidimensionnel de 10 lignes de 12 décimaux chacune comme ci‑dessous :
   float decadeMonthlyTemp_C[10][12] = {0.0};
   avec, encore ici, tous les éléments du tableau initialisés à zéro.

1. En prolongement de l'exemple 2) supra  de relevés mensuels de température, pour calculer la moyenne annuelle des températures à partir du relevé, on peut procéder comme dans le programme ci‑dessous :

#include <stdio.h>

int main(void) 
{
  const float MONTHLY_TEMP_C[12] = {6.0, 8.7, 8.1, 13.1, 14.3, 17.3, 19.2, 21.2, 17.2, 12.2, 9.3, 6.2};
  float yearlySum = 0;
  for (int month = 0; month <= 11; month++) {
    yearlySum += MONTHLY_TEMP_C[month];
  }
  printf("Yearly average temp.  = %g °C\n", yearlySum / 12);
  return 0;
}

Ici, la constante de type tableau MONTHLY_TEMP_C est accédée en lecture, élément par élément, pour en faire la somme (cf. la ligne nº 8) dans la variable yearlySum. Ce calcul est effectué dans le cadre d'une boucle for où l'indice courant month va de 0 à 11 inclus (il s'agit donc du numéro du mois décalé de −1, donc 0 pour janvier, 1 pour février, etc.).
La moyenne annuelles est affichée à la ligne suivante, en divisant la somme des moyennes mensuelles yearlySum par l'effectif (12 – le nombre de mois dans l'année).

2. En prolongement de l'exemple 1) supra de codage des bandes de couleur d'un résistor , on peut calculer la valeur ohmique du résistor à partir de la donnée de ses couleurs de bandes, et vice‑versa, comme dans le programme codé ci‑dessous :

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

int main(void) 
{
  /* 1 - Resistance calculus from the color strips */
  const int STRIPES_R1[4] = {1, 0, 2, 5};  // brown, black, red, gold
  unsigned long resist_R1 = (STRIPES_R1[0] * 10 + STRIPES_R1[1]) * pow(10, STRIPES_R1[2]);
  printf("Resistance R1 = %lu ± %g Ω\n", resist_R1, resist_R1 * STRIPES_R1[3] / 100.0);
  
  /* 2 - Color strip calculus from the resistance */
  const unsigned long RESIST_R2 = 56000; // ohm
  int stripes_R2[4] = {0};
  unsigned long calc_R2 = RESIST_R2;
  while (calc_R2 % 10 == 0) {
    calc_R2 = calc_R2 / 10;
    stripes_R2[2]++;
  }
  if (calc_R2 > 10) {
    stripes_R2[0] = calc_R2 / 10;
    stripes_R2[1] = calc_R2 % 10;
  }
  else {
    stripes_R2[0] = calc_R2;
    stripes_R2[0] = 0;
  }
  printf("Strips R2 = %d, %d, %d, 5\n", stripes_R2[0], stripes_R2[1], stripes_R2[2]);
  return 0;
}

Dans la première partie de la fonction main :
• à la ligne nº 7, on déclare une constante de type tableau STRIPES_R1 pour représenter les bandes de couleur d'un résistor ;
• à ligne nº 8, on déclare une variable entière resist_R1 pour y calculer la valeur ohmique du résistor en appliquant la formule ①② × 10^③ où ① ② ③ représentant les chiffres codés par les bandes de couleur – et c'est précisément ici qu'on accède en lecture aux éléments tableaux ;
• à la ligne nº 9, on affiche cette valeur et son intervalle de tolérance calculé à l'aide de la 4^e bande de couleur (3^e élément du tableau).
Dans la deuxième partie de la fonction main :
• à la ligne nº 12, on déclare une constante entière RESIST_R2 pour mémoriser une valeur de résistance en ohm ;
• à ligne nº 13, on déclare une variable de type tableau stripes_R2 dans laquelle on va déterminer les bandes de couleur correspondant à la résistance mémorisée ;
• à la ligne nº 14, on déclare une variable intermédiaire calc_R2 pour la détermination des bandes de couleurs, initialisée à la valeur de RESIST_R2 ;
• l'algorithme de détermination des bandes de couleurs procède par divisions successives par 10 de la valeur de calc_R2 (cf. les lignes nº 15 à 26) ; ici, les éléments du tableaux font l'objet d'affectations (accès en écriture) ;
• à la ligne nº 27, on affiche dans l'ordre les 4 chiffres correspondant aux bandes de couleur (le 4^e chiffre est supposé valoir toujours 5 – il code la bande de qualité à 5 %).
Remarques.
• Ce programme ne donne des valeurs correctes que pour des résistances supérieures à 10 Ω.
• Les instructions d'affichage avec la fonction printf seront étudiées au chap. C2‑VII .

En prolongement de l'exemple de déclaration d'un tableau bidimensionnel proposé supra , le programme ci‑dessous met en œuvre une version très rudimentaire du jeu Puissance 4 où, dans un terminal d'exécution, deux joueurs peuvent tour à tour placer des jetons jusqu'à ce que le support soit plein, sachant que :

• le programme ne vérifie pas si un joueur a gagné ;
• les jetons des deux joueurs sont respectivement représentés symboliquement par des « 1 » et des « 2 », les emplacements vides par des « 0 » ;
• l'affichage du support de jeu (tableau) est statique. À chaque coup, il est ré‑affiché en dessous du précédent.

/* Minimal C version ot the Connect-4 game
 *  only allows 2 players to drop tokens in the board until it is full
 *  do not check if a player has won
 *  statically displays the board with '1' and '2' as players tokens ('0' if place empty)
*/

#include <stdio.h>

#define NB_COL 7 // cannot be declared as a real constant (array dimension)
#define NB_ROW 6 // idem
const int MAX_MOVE = NB_COL * NB_ROW; // max number of moves than both players can do


void display(int board[][NB_COL])
{
  for (int row = NB_ROW - 1; row >= 0; row--) {
    for (int col = 0; col < NB_COL; col++) {
      printf("%d ", board[row][col]);
      if (col == NB_COL - 1)  printf("\n");
    }
  }
}


int main(void)
{ 
  int board[NB_ROW][NB_COL] = {{0}};
  
  printf("***** CONNECT-4 MINIMAL GAME *****\n");
  for (int move = 0; move < MAX_MOVE; move++) {
    display(board);

    /* offers the player to drop a token in the board */
    int player = 1 + move % 2; // player alternates 1 / 2 
    int row = -1, col = -1;    // -1 means not yet chosen
    do {
      printf("Player %d choose an UNFULL COLUMN NUMBER\n 0 - 6 (out of range to ABORT): ", player);
      scanf(" %d", &col); // one col number (0 - 6) among those displayed on the board
      if (0 > col || col >= NB_COL) return -1; // out of range => player aborts game
      for (int r = 0; r < NB_ROW; r++) {   // seeking the first free row in the chosen column
        if (board[r][col] == 0) {  
          row = r;
          board[row][col] = player;
          break;
        } 
        if (r == NB_ROW - 1) {
          row = -1; 
          printf("\tColumn is full!\n");
        }
      }
    }
    while (row == -1); 
  }
  
  display(board);
  printf("Game over. Bye!\n");
  
  return 0;
}

Dans ce programme :

• La variable board de type tableau bidimensionnel est déclarée à la ligne nº 27 ; les nombres de lignes et de colonnes (6 × 7) sont respectivement codés par les deux pseudo‑constantes NB_ROW et NB_COL, elles‑mêmes respectivement définies aux lignes nº 9 & 10.
Attention : la ligne nº 0 correspond à celle du bas sur le support de jeu.
• Une fonction display est définie pour exécuter l'affichage du tableau (cf. les lignes nº 14 à 22). Elle est appelée deux fois dans la fonction principale du programme (cf. les lignes nº 31 & 55).
• Dans cette fonction, les éléments du tableau board sont accédés en lecture (cf. la ligne nº 18) dans le cadre d'une double boucle for pour afficher à chaque coup l'état courant du support de jeu.
• À chaque coup valable, l'élément du tableau board correspondant à l'emplacement du jeton joué est accédé en écriture à la ligne nº 43 ; il prend la valeur du numéro du joueur, mémorisé dans la variable player.

Exécuté sur OnlineGDB, ce programme produit typiquement une sortie comme ci‑dessous :

***** CONNECT-4 MINIMAL GAME *****
0 0 0 0 0 0 0 
0 0 0 0 0 0 0 
0 0 0 0 0 0 0 
0 0 0 0 0 0 0 
0 0 0 0 0 0 0 
0 0 0 0 0 0 0 
Player 1 choose an UNFULL COLUMN NUMBER
 0 - 6 (out of range to ABORT): 3
0 0 0 0 0 0 0 
0 0 0 0 0 0 0 
0 0 0 0 0 0 0 
0 0 0 0 0 0 0 
0 0 0 0 0 0 0 
0 0 0 1 0 0 0 
Player 2 choose an UNFULL COLUMN NUMBER
 0 - 6 (out of range to ABORT): 4
0 0 0 0 0 0 0 
0 0 0 0 0 0 0 
0 0 0 0 0 0 0 
0 0 0 0 0 0 0 
0 0 0 0 0 0 0 
0 0 0 1 2 0 0 
Player 1 choose an UNFULL COLUMN NUMBER
 0 - 6 (out of range to ABORT): ...

Pour mémoriser la température maximale mensuelle relevée en un lieu donné, il est utile de l'associer à la date à la quelle le relevé a été fait. On peut donc créer une structure à « un niveau » de la forme :

  Température maximale mensuelle :
    - jour  (nombre entier)
    - mois  (nombre entier)
    - année (nombre entier)
    - température  (nombre décimal)

Dans l'exemple précédent, pour mémoriser la température maximale mensuelle, on peut aussi concevoir une structure à « deux niveaux » comme ci‑dessous :

  Température maximale mensuelle :
    - date (structure) :
      - jour  (nombre entier)
      - mois  (nombre entier)
      - année (nombre entier)
    - température  (nombre décimal)

1. Pour stocker la température maximale mensuelle à une date donnée, par exemple en juillet 2020 à Versailles La Lanterne, atteinte le vendredi 31 avec la valeur de 38,5 °C , on peut coder la déclaration de la structure hétérogène suivante :

const struct { 
  int day; 
  int month; 
  int year; 
  float temperature; 
} MAX_TEMP_JULY_2020 = {31, 7, 2020, 38.5};

Bien entendu, cette donnée a été déclarée constante car elle n'est pas censée changer.

2. Pour stocker les différentes caractéristiques d'un résistor, par exemple celui représenté en figure ci‑contre, à savoir R = 1 kΩ ±5 % et P_max = ¼ W, on peut coder la déclaration d'une structure suivante :

const struct { 
  float resistance; 
  float quality; 
  float maxPower; 
} resistor_R1 = {1000.0, 0.05, 0.25};

Là encore, on déclare cette structure comme étant constante car une telle donnée n'est pas susceptible de changer.
Remarque. Même si tous les champs de la structures sont de même type, il serait moins pertinent de déclarer à la place un tableau de 3 éléments, car les grandeurs qu'ils représentent ne sont pas de même nature.

La déclaration de la constante de type structure maxTempSept2020 de l'exemple supra  peut être codée en deux temps, via la déclaration d'un type nommé comme ci‑dessous :

struct MaxTemp {
  int day; 
  int month; 
  int year; 
  float temperature; 
};

const struct MaxTemp MAX_TEMP_JULY_2020 = {31, 7, 2020, 38.5};

avec :

• la déclaration du type nommé MaxTemp aux lignes nº 10 à 15 ;
• la déclaration de la constante maxTempSept2020 de type MaxTemp à la ligne nº 17.

struct Date {
  int day; 
  int month; 
  int year; 
};

struct MaxTemp {
  struct Date date;
  float temperature; 
};

const struct MaxTemp MAX_TEMP_JULY_2020 = {{31, 7, 2020}, 38.5};

En prolongation des exemples précédents de déclaration d'une structure pour mémoriser température maximale mensuelle (cf. supra ), supposons que l'on veuille mémoriser la température maximale annuelle. Pour cela, il suffit de déclarer une deuxième constante du type MaxTemp, nommée par exemple MAX_TEMP_2020, et dans cette déclaration, de coder une affectation globale de la valeur de celle du mois où ce maximum s'est produit. C'est ce que l'on peut lire ci‑dessous à la ligne nº 18.

struct MaxTemp {
  int day; 
  int month; 
  int year; 
  float temperature; 
};

const struct MaxTemp MAX_TEMP_JULY_2020 = {31, 7, 2020, 38.5};
const struct MaxTemp MAX_TEMP_2020 = MAX_TEMP_JULY_2020;

1. Par un appel de la fonction printf, le programme ci‑dessous effectue dans le terminal d'exécution l'affichage des détails d'un enregistrement de température maximale dans un texte d'accompagnement explicite. Ce faisant, on code donc un accès en lecture aux différents champs de la constante structurée MAX_TEMP (cf. les lignes nº 16 & 17).

#include <stdio.h>

struct MaxTemp {
  int day; 
  int month; 
  int year; 
  float temperature; 
};

const struct MaxTemp MAX_TEMP_2020 = {31, 7, 2020, 38.5};

int main(void)
{
  printf("Capteur de Versailles La Lanterne\n");
  printf("Température maximale pour l'année %d le %02d/%02d : %g °C\n",
          MAX_TEMP_2020.year, MAX_TEMP_2020.day, MAX_TEMP_2020.month,
          MAX_TEMP_2020.temperature);
  return 0;
}

En adoptant une structuration à deux niveaux comme proposé supra , le programme ci‑dessus devient :
#include <stdio.h>

struct Date {
  int day; 
  int month; 
  int year; 
};

struct MaxTemp {
  struct Date  date;
  float temperature; 
};

const struct MaxTemp MAX_TEMP_2020 = {{31, 7, 2020}, 38.5};

int main(void)
{
  printf("Capteur de Versailles La Lanterne\n");
  printf("Temp. maxi. pour l'année %d le %02d/%02d : %g °C\n",
          MAX_TEMP_2020.date.year, MAX_TEMP_2020.date.day, MAX_TEMP_2020.date.month, 
          MAX_TEMP_2020.temperature);
  return 0;
}
Dans la fonction main, l'accès en lecture aux champs de la date se code alors par une double composition de l'opérateur de sélection (cf. les lignes nº 20 & 21).

2. En utilisant la donnée structurée de résistor déclarée supra , le programme de décodage des bandes de couleurs proposé en section I  peut se coder comme ci‑dessous avec des accès aux champs en écriture (cf. les lignes nº 14 & 15) et en lecture (cf. la ligne nº 18) :

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

struct { 
  float resistance; 
  float quality; 
  float maxPower; 
} resistor_R1 = {0.0, 0.0, 0.25}; // alway 1/4 W

int main(void)
{
  const int STRIPES_R1[4] = {1, 0, 2, 5};  // brown, black, red, gold

  resistor_R1.resistance = (STRIPES_R1[0] * 10 + STRIPES_R1[1]) * pow(10.0, STRIPES_R1[2]);
  resistor_R1.quality = STRIPES_R1[3] / 100.0;


  printf("Resistance R1 = %.0f ± %g Ω\n", resistor_R1.resistance, resistor_R1.resistance * resistor_R1.quality);
  return 0;
}

Remarque : cette fois, on a déclaré une variable (et non plus une constante) puisqu'on est amené à en modifier les champs (dans la mesure où le programme les calcule).