Pour mémoriser des dates calendaires dans un format habituel – jour, mois, année – on peut préalablement coder la déclaration d'un type structuré nommé Date comme ci‑dessous, composé de 3 champs day, month et year :

#include <stdint.h>

struct Date {
  int8_t day;   // 1 to 31
  int8_t month; // 1 to 12
  int16_t year; 
};

Par rapport à un tableau de trois éléments comme int16_t[3], l'emploi d'un type structuré comme celui déclaré ci‑dessus présente deux avantages :

• être plus économe en mémoire, puisque les espaces réservés au numéros de jour et de mois sont chacun codés avec le plus petit type élémentaire du langage (int8_t) ;
• donner des noms explicites aux composantes de la données, plutôt que de simples numéros d'ordre d'éléments du tableau, ce qui rendra plus lisible le codage des manipulations de ces champs.

Reprenons l'exemple supra  de la structure hétérogène Date (non synonyme) de type struct pour mémoriser des dates calendaires.

struct Date {
  int8_t  day;   // 1 to 31
  int8_t  month; // 1 to 12
  int16_t year; 
};

Suite à cette déclaration, on peut coder la déclaration de diverses données de ce type comme, par exemple, les trois dates proposées dans le code ci‑dessous :

const struct Date PRODUCTION_DATE = {27, 3, 2019};
struct       Date lastCheckDate   = {15, 9, 2019};
struct       Date nextCheckDate   = {15, 3, 2020};

const struct Date PRODUCTION_DATE = {27, 3, 2019};
struct       Date lastCheckDate   = {15, 9, 2019},
                  nextCheckDate   = {15, 3, 2020};

Au chapitre C4‑V , pour gérer les signaux logiques reçus en entrée (boutons‑poussoirs, capteurs TOR, etc.) sur les broches du port numérique d'une carte Arduino – notamment, pour actualiser les valeurs des niveaux logiques, détecter les fronts montants et descendants, etc. – on avait codé un module de bibliothèque. Dans son fichier d'en‑tête LogicalSignals.h, on avait déclaré le type structuré LogicalSignal :

typedef struct { /* OLD VERSION */ 
  uint8_t pin;  // pin number on the board
  byte levels;  // only bit 0 and 1 used
} LogicalSignal;    

Ce type est composé des 2 champs occupant 1 octet chacun, soit au total 2 octets :

• le champ pin code le numéro de broche de la carte sur laquelle les signaux logiques sont reçus ;

or, même pour une carte Arduino Mega, on n'a que 54 broches d'entrées-sorties numériques, donc le champ pin ne requiert en fait que 6 bits (2⁶ = 64 numéros codables) ;
quant au champ levels, il code sur ses bits de rangs 0 et 1 les niveaux logiques respectivement actuel et précédent lus sur la broche ; les autres bits sont inusités.

En utilisant des champs de bits comme ci‑dessous, on peut donc réduire à 1 seul octet la taille occupée en mémoire par les données de ce type :

typedef struct { /* NEW VERSION */
  uint8_t pin           : 6;
  uint8_t currentLevel  : 1;
  uint8_t previousLevel : 1;
} LogicalSignal;

Par ailleurs, cette solution apporte un surcroît de lisibilité pour les champs dédiés à l'enregistrement des niveaux logiques, car ils ont maintenant des noms explicites, contrairement à de simples rangs de bits. Ainsi, la déclaration d'une donnée de type LogicalSignal associée à un bouton poussoir peut se coder comme ci‑dessous :

LogicalSignal buttonSignal = {
  .pin = BUTTON_PIN,
  .currentLevel  = LOW, // positive logic
  .previousLevel = LOW 
};

Reprenons l'exemple supra  de la structure hétérogène Date codée de type struct (non synonyme) pour mémoriser des dates calendaires.

struct Date {
  int8_t  day;   // 1 to 31
  int8_t  month; // 1 to 12
  int16_t year; 
};

On identifie ses champs day, month et year respectivement par les expressions :

• PRODUCTION_DATE.day
• PRODUCTION_DATE.month
• PRODUCTION_DATE.year

On peut donc les employer dans un programme comme par exemple dans le test ci‑dessous :
if (PRODUCTION_DATE.year < 2019) …

Reprenons l'exemple supra  de la structure hétérogène Date codée de type struct (non synonyme) pour mémoriser des dates calendaires.

struct Date {
  int8_t  day;   // 1 to 31
  int8_t  month; // 1 to 12
  int16_t year; 
};

On avait aussi codé plus loin la déclaration de la donnée PRODUCTION_DATE qui est une constante de ce type :

const struct Date PRODUCTION_DATE = {27, 3, 2019};  

Avec l'initialisation sélective de ses champs, cette déclaration peut aussi se coder comme ci‑dessous, les champs étant sélectionnés dans n'importe quel ordre :

const struct Date PRODUCTION_DATE = {.year = 2019, .day = 27, .month = 3};  

ou encore – même si c'est bien moins lisible, en respectant l'ordre de déclaration des champs :

const struct Date PRODUCTION_DATE = {27, 3, .year = 2019};  

const struct Date PRODUCTION_DATE = {.year = 2019, 27, 3}; // WRONG ORDER!  

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

struct Date {
  int8_t day;   // 1 to 31
  int8_t month; // 1 to 12
  int16_t year; 
};

const struct Date PRODUCTION_DATE = {.year = 2019, 27, 3}; // WRONG ORDER!

int main(void)
{
  printf("%02d/%02d/%d\n", PRODUCTION_DATE.day, PRODUCTION_DATE.month, PRODUCTION_DATE.year);
  return 0;
}

main.c:10:52: warning: excess elements in struct initializer
   10 | const struct Date PRODUCTION_DATE = {.year = 2019, 27, 3}; // WRONG ORDER!
      |                                                    ^~
main.c:10:52: note: (near initialization for ‘PRODUCTION_DATE’)
main.c:10:56: warning: excess elements in struct initializer
   10 | const struct Date PRODUCTION_DATE = {.year = 2019, 27, 3}; // WRONG ORDER!
      |                                                        ^
main.c:10:56: note: (near initialization for ‘PRODUCTION_DATE’)
00/00/2019

Reprenons l'exemple supra  de la structure hétérogène Date codée de type struct (non synonyme) pour mémoriser des dates calendaires.

struct Date {
  int8_t  day;   // 1 to 31
  int8_t  month; // 1 to 12
  int16_t year; 
};

On avait aussi codé plus loin la déclaration de la variable lastCheckDate :

struct       Date lastCheckDate   = {15, 9, 2019};

Sur cette donnée structurée, on peut déclarer un pointeur nommé p_date tout simplement comme ci‑dessous :

struct Date * p_date = &lastCheckDate;

En prolongeant l'exemple récurrent des dates calendaires déclarées via le type structuré nommé Date, on souhaite définir des dates d'échéances trimestrielles pour le remboursement d'un crédit, fixée au 5 du premier mois de chaque trimestre. Dans le programme ci‑dessous (cf. la ligne nº 12), on déclare donc un tableau dueDate de 4 éléments du type Date.

Dans une première version de la fonction main du programme, on code dans une boucle for de façon usuelle – c'est‑à‑dire avec l'opérateur d'indexation [] et l'opérateur de sélection . – l'affectation et l'affichage des valeurs des champs des éléments de ce tableau.

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

#define nbOfElements(array) (sizeof(array)/sizeof(array[0])) 
 
struct Date {
  int8_t day;   // 1 to 31
  int8_t month; // 1 to 12
  int16_t year; 
};  
 
struct Date paymentDate[4]; 
 
int main(void)
{
  printf("Loan payment dates:\n");
  for (int k = 0; k < nbOfElements(paymentDate); k++) {
    paymentDate[k].day   = 5;
    paymentDate[k].month = 3 * k + 1;
    paymentDate[k].year  = 2022;
    printf("  %02d/%02d/%d\n", paymentDate[k].day, paymentDate[k].month, paymentDate[k].year);
  }
  return 0;
} 

Sans surprise, sur OnlineGDB, ce programme produit la sortie attendue suivante :

Loan payment dates:
  05/01/2022
  05/04/2022
  05/07/2022
  05/10/2022

En ayant recours à un pointeur initialisé sur le premier élément du tableau (cf. ci‑dessous la ligne nº 16), et en utilisant l'opérateur « flèche », la fonction main du programme ci‑dessus peut alors se coder comme ci‑dessous :

int main(void)
{
  struct Date * const p_firstPaymentDate = &paymentDate[0];
  printf("Loan payment dates:\n");
  for (struct Date * p = p_firstPaymentDate; p < p_firstPaymentDate + nbOfElements(paymentDate); p++) {
    p -> day   = 5;
    p -> month = 3 * (p - p_firstPaymentDate) + 1;
    p -> year  = 2022;
    printf("  %02d/%02d/%d\n", p -> day, p -> month, p -> year);
  }
  return 0;
}   

Cette solution de codage présente une bonne lisibilité sauf à la ligne nº 18 pour déterminer le numéro d'itération de la boucle, ce qui nécessite une opération de décalage p - p_firstPaymentDate.

Reprenons l'exemple supra  de la structure hétérogène Date codée de type struct (non synonyme) pour mémoriser des dates calendaires.

struct Date {
  int8_t  day;   // 1 to 31
  int8_t  month; // 1 to 12
  int16_t year; 
};

Plus loin, on avait également déclaré les deux variables ci‑dessous :

struct       Date lastCheckDate   = {15, 9, 2019};
struct       Date nextCheckDate   = {15, 3, 2020};

Sans problème, on peut coder une instruction d'affectation pour copier la valeur de l'une dans l'autre, par exemple comme ceci :

  lastCheckDate = nextCheckDate; // global assignation

Et suite à la déclaration d'un pointeur p_date de type Date* telle que supra , on peut aussi coder une affectation comme, par exemple :

  lastCheckDate = *p_date; // global assignation

ou encore :

  *p_date = lastCheckDate; // global assignation

si tant est que p_date ne pointe pas sur une donnée constante.

Reprenons l'exemple de la gestion des signaux logiques pour l'environnement Arduino pour lequel on avait proposé au chap. C4‑VI  un module de fonctions dédiées.

Toutes ces fonctions ont la particularité de prendre un argument formel de type struct nommé LogicalSignal (déclaré comme synonyme). Et à l'exception de la fonction updateSignal, cet argument est systématiquement transmis par valeur.

Avec la nouvelle composition du type LogicalSignal proposée supra , on peut aisément recoder ces fonctions d'une manière bien plus lisible .

Prenons le cas de risingEdge qui retourne la valeur booléenne 1 lors de l'occurrence d'un front montant sur le signal de tension d'une broche d'entrée du port numérique de la carte.

bool risingEdge(LogicalSignal inputSignal)
{
  return (inputSignal.previousLevel == LOW && 
          inputSignal.currentLevel  == HIGH);
}

Une expression d'appel de cette fonction se code dans difficulté aucune, par exemple :

  if (risingEdge(buttonSignal)) {
    // ...
  }

où buttonSignal est une variable de type LogicalSignal préalablement déclarée (typiquement associée à une broche de la carte qui est reliée à un bouton‑poussoir).

Continuons avec l'exemple de la gestion des signaux logiques dans l'environnement Arduino pour lequel on avait proposé au chap. C4‑VI  un module de fonctions dédiées.

Comme on l'a souligné supra , toutes les fonctions de ce module prennent un argument formel de type struct nommé LogicalSignal (déclaré comme synonyme). Mais la fonction updateSignal a la particularité qu'elle doit opérer une modification de son argument effectif (elle effectue la mise à jour des niveaux logiques de tension mémorisés sur une broche d'entrée du port numérique de la carte). La transmission ne peut donc pas s'opérer par valeur.

La solution la plus indiquée consiste donc à opter pour une transmission par référence. Avec la composition du type LogicalSignal telle que proposée supra , on peut coder la fonction updateSignal d'une manière bien plus lisible, comme ci‑dessous :

void updateSignal(LogicalSignal & inputSignal)
{
  inputSignal.previousLevel = inputSignal.currentLevel;
  inputSignal.currentLevel  = digitalRead(inputSignal.pin);
}

Appliqué à une variable buttonSignal de déclarée de type LogicalSignal, une instruction d'appel de la fonction updateSignal se code simplement :

  updateSignal(buttonSignal); 

On peut donc maintenant proposer un programme complet exploitant ces éléments de codage, par exemple pour le montage donné au chap. C2‑VIII . Ce programme permet d'allumer et d'éteindre la led intégrée d'une carte Arduino Uno à l'aide d'un bouton‑poussoir raccordé à l'entrée 8 du port numérique de la carte.

const int LED_PIN = LED_BUILTIN;
const int BUTTON_PIN = 8;

typedef struct { 
  uint8_t pin           : 6;
  uint8_t currentLevel  : 1;
  uint8_t previousLevel : 1;
} LogicalSignal;

LogicalSignal buttonSignal = {
  .pin = BUTTON_PIN,
  .currentLevel  = LOW, // positive logic
  .previousLevel = LOW 
};


void setup()
{
  pinMode(LED_PIN, OUTPUT);
  pinMode(BUTTON_PIN, INPUT);
}


void loop()
{
  updateSignal(buttonSignal);
  if (risingEdge(buttonSignal)) {
    digitalWrite(LED_PIN, !digitalRead(LED_PIN));
  }
}


void updateSignal(LogicalSignal & inputSignal)
{
  inputSignal.previousLevel = inputSignal.currentLevel;
  inputSignal.currentLevel  = digitalRead(inputSignal.pin);
}


bool risingEdge(LogicalSignal inputSignal)
{
  return (inputSignal.previousLevel == LOW && 
          inputSignal.currentLevel  == HIGH);
}

Reprenons l'exemple de la gestion des signaux logiques dans l'environnement Arduino, pour lequel on a proposé supra  un codage de la fonction updateSignal mettant en œuvre une transmission d'argument par référence. Pour une transmission par adresse, on peut utiliser l'opérateur « flèche » -> (cf. supra ) qui améliore la lisibilité du code :

void updateSignal(LogicalSignal * p_inputSignal) {
  p_inputSignal -> previousLevel = p_inputSignal -> currentLevel;
  p_inputSignal -> currentLevel  = digitalRead(p_inputSignal -> pin);
}

Quant à un appel de cette fonction pour la variable buttonSignal de type LogicalSignal, il se code bien entendu en utilisant l'opérateur d'adresse & appliqué à la variable buttonSignal :

  updateSignal(&buttonSignal); 

Reprenons l'exemple supra  de la structure hétérogène Date codée de type struct (non synonyme) pour mémoriser des dates calendaires.

struct Date {
  int8_t  day;   // 1 to 31
  int8_t  month; // 1 to 12
  int16_t year; 
};

On code ici une fonction nommée firstDayOfMonth qui retourne comme valeur le 1^er jour du mois d'une date passée comme argument de cette fonction :

struct Date firstDayOfMonth(struct Date givenDate) {
  struct Date firstDay = {1, givenDate.month, givenDate.year};
  return firstDay;
}

Sachant qu'on avait également déclaré une variable nommée nextCheckDate de type Date, on peut alors coder un appel de la fonction firstDayOfMonth pour effectuer une affectation globale, par exemple ainsi :

  struct Date warningDay = firstDayOfMonth(nextCheckDate);

Reprenons l'exemple supra  de la structure hétérogène Date codée de type struct (non synonyme) pour mémoriser des dates calendaires.

struct Date {
  int8_t  day;   // 1 to 31
  int8_t  month; // 1 to 12
  int16_t year; 
};

On présente ici le codage de deux fonctions spécifiques pour effectuer des comparaisons d'égalité et d'antériorité de dates.

1. Pour tester l'égalité de deux dates données d1 et d2, on peut coder la fonction areEqual ci‑dessous. Elle vérifie si tous les champs de ses deux arguments sont respectivement égaux :

bool areEqual(struct Date d1, struct Date d2)
{
  return (d1.day   == d2.day   &&
          d1.month == d2.month &&
          d1.year  == d2.year);
}

2. Pour tester l'antériorité d'une date d1 par rapport à une date d2, on peut coder la fonction isAnterior ci‑dessous. Elle teste l'infériorité des champs de d1 par rapport à ceux de d2 en procédant par ordre de poids décroissants (années, mois, jours) :

bool isAnterior(struct Date d1, struct Date d2)
{
  if      (d1.year < d2.year) return true;
  else if (d1.year > d2.year) return false;
  else //  d1.year == d2.year
       if      (d1.month < d2.month) return true;
       else if (d1.month > d2.month) return false;
       else //  d1.month == d2.month
            if     (d1.day <  d2.day)   return true;
            else /* d1.day >= d2.day */ return false;
}

On voit donc ici que pour une problématique finalement assez simple, la mise en place d'une relation d'ordre sur des données structurée est plus complexe qu'il n'y parait (elle ne se résume pas à la simple comparaison de deux scalaires).
Remarque. Si les dates étaient exprimées sous la forme de timestamp avec le type time_t (cf. chap. R2‑VI R), cette complexité ne se poserait pas puisqu'il s'agit d'un type scalaire.

Pour coder les couleurs d'un pixel ou d'une led RGB, respectivement en synthèses additive et soustractive (cf. TP3‑2 ), on peut par exemple déclarer comme ci‑dessous les deux types synonymes structurés RGBcode et CMYcode (on verra dans la partie consacrée aux structures par superposition pourquoi l'ordre des champs est inversé par rapport à celui du sigle RGB ) :

typedef struct {
  uint8_t blue, green, red;
} RGBcode;
  
typedef struct {
  uint8_t yellow, magenta, cyan;
} CMYcode;

Rappelons que pour une couleur donnée dans l'un de ces deux types ci‑dessus, on obtient sa couleur complémentaire W par transcodage direct d'un type à l'autre. Par exemple, la couleur complémentaire du rouge saturé, codé (255, 0, 0) en RGB, est le cyan saturé, codé (255, 0, 0) en CMY (sur les rosaces respectives des couleurs primaires et secondaires, les couleurs complémentaires sont en vis‑à‑vis, comme on peut le voir sur la figure ci‑contre).

Pour définir une fonction de complémentation nommée complRGBtoCMY qui prend comme argument une couleur de type RGBcode et retourne sa couleur complémentaire de type CMYcode, on ne peut pas procéder par une affectation directe comme ci‑dessous :

CMYcode complRGBtoCMY(RGBcode rgbColor) {
  return rgbColor;  // DOESN'T WORK! (imcompatible types)
}

En effet, le type de la valeur de retour est différent de celui de l'argument (bien qu'identique en termes de structure) et aucune conversion, ni implicite ni explicite, n'est possible entre types struct.

Pour coder la fonction complRGBtoCMY, il n'y a donc pas d'autre choix que de déclarer une variable locale de type CMYcode et de procéder à l'initialisation de chacun de ses champs par affectations des valeurs respectives de ceux de son argument, comme ci‑dessous. Cela revient en fait à coder une fonction de transtypage.

CMYcode complRGBtoCMY(RGBcode rgbColor) {
  CMYcode cmyColor = {
    .yellow  = rgbColor.blue,
    .magenta = rgbColor.green, 
    .cyan    = rgbColor.red
  };
  return cmyColor;
}

On peut alors coder l'initialisation d'une constante CMY_CYAN à partir de sa complémentaire RGB_RED en utilisant cette fonction comme ci‑dessous :

  const RGBcode RGB_RED  = {.blue = 0, .green = 0, .red = 255};
  const CMYcode CMY_CYAN = complRGBtoCMY(RGB_RED);

Au chapitre C5‑I , on a vu comment on pouvait, grâce à un pointeur, interpréter dans le format uint32_t (binaire naturel sur 32 bits) le détail des bits encodant la valeur d'une donnée a de type float (même taille).

Pour mémoire, l'encodage d'une donnée de type float comporte 3 composantes qui codent respectivement le signe s(1 bit), l'exposant décalé q (8 bits) et le significande f ou partie fractionnaire de la mantisse (23 bits) – cf. chap. C3‑V ).

Ainsi, on avait obtenu pu afficher l'encodage binaire Ox3F800000 de la valeur décimale 1.0 affectée à une donnée de type float.

Toutefois, pour retrouver les valeurs respectives des 3 composantes du format float, un décodage restait à opérer puisque les champs de bits de ces composantes sont à cheval sur les octets de la mémoire.

Et en effet, la valeur Ox3F800000 n'est pas simple à interpréter, même pour un codeur expérimenté.

Eh bien, il est possible d'obtenir très facilement les valeurs de ces 3 composantes en déclarant un type union constitué de deux champs superposés :

• Le premier champ est de type float. Il permet de coder simplement la valeur décimale de la donnée via la syntaxe usuelle.
• Le deuxième champ est de type struct. Il est constitué de 3 champs de bits de format d'enveloppe uint32_t de longueurs respectives 23 (significande), 8 (exposant décalé) et 1 (signe).
Ces 3 champs de bits doivent être déclarés dans cet ordre, puisque le bit de signe a le dernier rang (31) dans l'encodage du type float et qu'a priori, on opère sur une machine et un système petit boutiste (cf. chap. C3‑I ).

Dans le programme ci‑dessous, on définit donc (lignes nº 4 à 11) comme synonyme le type StructuredFloat superposant comme indiqué ci‑dessus un champ décimal decimal et un champ structuré field.

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

typedef union {
  float decimal;
  struct {
    uint32_t mantissa : 23;
    uint32_t exponent :  8;
    uint32_t sign     :  1;
  } field;
} StructuredFloat;   

int main(void)
{
  StructuredFloat a = {.decimal = 1.0};
  printf("Decimal %g : sign %u, exponent %u, mantissa %X\n", 
         a.decimal, a.field.sign, a.field.exponent, a.field.mantissa);
}

Dans la fonction main, on déclare alors une donnée a de type StructuredFloat (lignes nº 14) en l'initialisant avec la valeur 1.0 affectée à champ decimal.

On peut alors obtenir directement les 3 composantes de son encodage binaire par sélection des champs de bits de son champ field. Exécuté sur OnlineGDB, on obtient en sortie standard l'affichage :

Decimal 1 : sign 0, exponent 127, mantissa 0 

ce qui attendu puisque, mathématiquement, on a l'égalité :
a  =  (−1)⁰ × (1 + 0,0) × 2^{127 − 127}  =  2⁰  =  1,0

Reprenons l'exemple supra  du codage des couleurs en synthèse additive pour un pixel d'écran ou une led RGB, pour lequel on avait définit le type structuré RGBcode comme ci‑dessous :

typedef struct {
  uint8_t blue, green, red;
} RGBcode;

Pour une meilleure polyvalence, on peut alternativement déclarer un type union constitué de deux champs superposés nommés hexCode et field :

• Le premier champ, nommé hexcode, est un champ de 24 bits déclaré sur une enveloppe en uint32_t pour définir le code hexadécimal global de la couleur tel qu'on s'en sert pour l'affichage des pages web en langages HTML/CSS.
Par exemple 0xFF0000 code le rouge saturé .
• Le deuxième champ, nommé field est un tableau de 3 éléments de type uint8_t, codant respectivement les valeurs des 3 composantes RGB de la couleur.
Ces valeurs étant de même type (entier compris entre 0 et 255), il est avantageux d'avoir recours à un tableau plutôt qu'un type struct car on pourra par la suite coder des traitements itératifs (boucles), tout en gardant une identification sélective lisible par le biais d'un type énuméré (on l'a fait à maintes reprises au chap. C5‑IV ).

Par ailleurs, sachant que dans le code hexadécimal d'une couleur, la composante rouge est codée sur l'octet de poids fort et la composante bleu sur l'octet de poids faible, il est nécessaire d'inverser l'ordre de codage des composantes dans le tableau par rapport à celui du sigle RGB.

On code donc le programme académique suivant qui, pour illustrer la polyvalence du type RGBcolor, affiche d'une part le code hexadécimal et d'autre part la décomposition décimale RGB de la couleur  gold   :

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

enum ColorLights {BLUE, GREEN, RED};

typedef union {
  uint32_t hexCode : 24; 
  uint8_t  field[3];
} RGBcolor ;

int main(void)
{
  const RGBcolor GOLD = {.hexCode = 0xFFD700};
  printf("Gold: hexcode %X (red %u, green %u, blue %u)\n", GOLD.hexCode,
          GOLD.field[RED], GOLD.field[GREEN], GOLD.field[BLUE]);
}

Sans surprise, sur OnlineGDB, on obtient en sortie standard l'affichage attendu :

Gold : hexcode FFD700 (red 255, green 215, blue 0)