ENIB LANG-C Ex_0401 - Accès au contexte appelant

{1} Première variante

D'une part, il faut déclarer et définir dans les fichiers pointers.h et pointers.c une fonction adjustMin() ayant les caractéristiques suivantes :

elle intervient sur deux réels du contexte appelant,
elle réduit l'écart entre ces deux valeurs en ajoutant à la plus petite des deux la moitié de l'écart qui la sépare de l'autre.

D'autre part, il faut réaliser, dans le fichier prog_ex0401.c, cette fonction :

void
test_adjustMin(void)
{
  printf("\n~~~~ test_adjustMin() ~~~~\n");
  // ...
}

qui sera appelée depuis la fonction main().
Elle doit être complétée en déclarant quelques variables réelles initialisées pour constater le bon fonctionnement de la fonction réalisée.
Il faudra les afficher avant et après plusieurs utilisations de la fonction adjustMin() qui ajusteront tantôt le premier paramètre tantôt le second.
Par exemple :

si deux réels valent initialement 5.0 et 8.0, le premier sera ajusté à 6.5,
si deux réels valent initialement 8.0 et 3.0, le second sera ajusté à 5.5.

{2} Deuxième variante

D'une part, il faut déclarer et définir dans les fichiers pointers.h et pointers.c une fonction adjustMax() ayant les caractéristiques suivantes :

elle intervient sur deux réels du contexte appelant,
elle réduit l'écart entre ces deux valeurs en retirant à la plus grande des deux la moitié de l'écart qui la sépare de l'autre.

D'autre part, il faut réaliser, dans le fichier prog_ex0401.c, cette fonction :

void
test_adjustMax(void)
{
  printf("\n~~~~ test_adjustMax() ~~~~\n");
  // ...
}

qui sera appelée depuis la fonction main().
Elle doit être complétée en déclarant quelques variables réelles initialisées pour constater le bon fonctionnement de la fonction réalisée.
Il faudra les afficher avant et après plusieurs utilisations de la fonction adjustMax() qui ajusteront tantôt le premier paramètre tantôt le second.
Par exemple :

si deux réels valent initialement 8.0 et 3.0, le premier sera ajusté à 5.5,
si deux réels valent initialement 3.0 et 6.0, le second sera ajusté à 4.5.

{3} Troisième variante

D'une part, il faut déclarer et définir dans les fichiers pointers.h et pointers.c une fonction decomposeTime() ayant les caractéristiques suivantes :

elle reçoit un premier paramètre duration de type réel,
grâce à deux autres paramètres, elle met à jour deux entiers du contexte appelant,
- l'un représente un nombre entier d'heures et sera directement obtenu à partir du paramètre duration,
- l'autre représente un nombre de minutes et sera obtenu par la formule (duration-nombre_d_heures)*60.0

D'autre part, il faut réaliser, dans le fichier prog_ex0401.c, cette fonction :

void
test_decomposeTime(void)
{
  printf("\n~~~~ test_decomposeTime() ~~~~\n");
  // ...
}

qui sera appelée depuis la fonction main().
Elle doit être complétée en déclarant quelques variables réelles et entières initialisées pour constater le bon fonctionnement de la fonction réalisée.
Par exemple :

une durée de 1.5 heures se décompose en 1 heure et 30 minutes,
une durée de 2.25 heures se décompose en 2 heures et 15 minutes.

Les règles de mise en œuvre et d'écriture recommandées dans toutes nos réalisations doivent impérativement être respectées.
(#ifndef..., fichiers d'en-tête, programmation modulaire...)
Seule la fonction de test produit des affichages (la fonctionnalité testée rend son service silencieusement) ; un examen attentif des affichages produits doit permettre de vérifier le bon fonctionnement de la fonctionnalité testée.
Le choix et le passage des paramètres ainsi que l'explicitation des étapes de lecture et d'écriture des données du contexte appelant constituent l'essentiel de l'exercice ; il n'est pas question de recourir à une formulation alternative qui produirait malgré tout un résultat équivalent.

Code source résultant

Si vous suivez scrupuleusement les énoncés et les consignes, vous devez obtenir des fichiers de code source semblables à ceux-ci :

Fichier pointers.h✎

Contenu du fichier pointers.h

//----------------------------------------------------------------------------

#ifndef POINTERS_H
#define POINTERS_H

void
adjustMin(double *inout_a,
          double *inout_b);

void
adjustMax(double *inout_a,
          double *inout_b);

void
decomposeTime(int *out_hours,
              int *out_minutes,
              double duration);

#endif // POINTERS_H

//----------------------------------------------------------------------------

Fichier pointers.c✎

Contenu du fichier pointers.c

//----------------------------------------------------------------------------

#include "pointers.h"

void
adjustMin(double *inout_a,
          double *inout_b)
{
  double a=*inout_a;
  double b=*inout_b;
  if(a<b)
  {
    a+=0.5*(b-a);
    *inout_a=a;
  }
  else
  {
    b+=0.5*(a-b);
    *inout_b=b;
  }
}

void
adjustMax(double *inout_a,
          double *inout_b)
{
  double a=*inout_a;
  double b=*inout_b;
  if(a>b)
  {
    a-=0.5*(a-b);
    *inout_a=a;
  }
  else
  {
    b-=0.5*(b-a);
    *inout_b=b;
  }
}

void
decomposeTime(int *out_hours,
              int *out_minutes,
              double duration)
{
  const int hours=(int)duration;
  const int minutes=(int)((duration-hours)*60.0);
  *out_hours=hours;
  *out_minutes=minutes;
}

//----------------------------------------------------------------------------

Fichier prog_ex0401.c✎

Contenu du fichier prog_ex0401.c

//----------------------------------------------------------------------------

#include "pointers.h"

#include <stdio.h>

void
test_adjustMin(void)
{
  printf("\n~~~~ test_adjustMin() ~~~~\n");
  double a=5.0, b=8.0, c=3.0;
  printf("before adjust min: a=%g b=%g c=%g\n", a, b, c);
  adjustMin(&a, &b);
  adjustMin(&b, &c);
  printf("after adjust min: a=%g b=%g c=%g\n", a, b, c);
}

void
test_adjustMax(void)
{
  printf("\n~~~~ test_adjustMax() ~~~~\n");
  double a=8.0, b=3.0, c=6.0;
  printf("before adjust max: a=%g b=%g c=%g\n", a, b, c);
  adjustMax(&a, &b);
  adjustMax(&b, &c);
  printf("after adjust max: a=%g b=%g c=%g\n", a, b, c);
}

void
test_decomposeTime(void)
{
  printf("\n~~~~ test_decomposeTime() ~~~~\n");
  const double d1=1.5, d2=2.25;
  int h1, m1, h2, m2;
  decomposeTime(&h1, &m1, d1);
  decomposeTime(&h2, &m2, d2);
  printf("duration %g --> %d h, %d m\n", d1, h1, m1);
  printf("duration %g --> %d h, %d m\n", d2, h2, m2);
}

int
main(void)
{
  test_adjustMin();
  test_adjustMax();
  test_decomposeTime();
  return 0;
}

//----------------------------------------------------------------------------