ENIB LANG-C Ex_0201 - Alternative simple et opérateur ternaire

{1} Première variante

D'une part, il faut déclarer et définir dans les fichiers alternative.h et alternative.c deux fonctions sign_v1() et sign_v2() ayant les caractéristiques suivantes :

elles attendent un paramètre de type réel,
elles fournissent un résultat de type réel,
si le paramètre est négatif, alors le résultat doit valoir -1.0, sinon il doit valoir 1.0,
sign_v1() doit reposer sur l'usage de l'alternative simple,
sign_v2() doit reposer sur l'usage de l'opérateur ternaire (opérateur conditionnel).

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

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

qui sera appelée depuis la fonction main().
Elle doit être complétée en déclarant quelques variables de type réel initialisées pour constater le bon fonctionnement des deux fonctions réalisées.
Il faudra afficher les valeurs de ces variables ainsi que le résultat des fonctions sign_v1() et sign_v2() qui leur seront appliquées.

{2} Deuxième variante

D'une part, il faut déclarer et définir dans les fichiers alternative.h et alternative.c deux fonctions signedSquare_v1() et signedSquare_v2() ayant les caractéristiques suivantes :

elles attendent un paramètre x de type réel,
elles fournissent un résultat de type réel,
si le paramètre est négatif, alors le résultat doit valoir -x*x, sinon il doit valoir x*x,
signedSquare_v1() doit reposer sur l'usage de l'alternative simple,
signedSquare_v2() doit reposer sur l'usage de l'opérateur ternaire (opérateur conditionnel).

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

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

{3} Troisième variante

D'une part, il faut déclarer et définir dans les fichiers alternative.h et alternative.c deux fonctions delta_v1() et delta_v2() ayant les caractéristiques suivantes :

elles attendent deux paramètres a et b de type entier,
elles fournissent un résultat de type entier,
si a est inférieur à b, alors le résultat doit valoir b-a, sinon il doit valoir a-b,
delta_v1() doit reposer sur l'usage de l'alternative simple,
delta_v2() doit reposer sur l'usage de l'opérateur ternaire (opérateur conditionnel).

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

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

qui sera appelée depuis la fonction main().
Elle doit être complétée en déclarant quelques variables de type entier initialisées pour constater le bon fonctionnement des deux fonctions réalisées.
Il faudra afficher les valeurs de ces variables ainsi que le résultat des fonctions delta_v1() et delta_v2() qui leur seront appliquées.

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.
L'usage de l'alternative simple dans un cas, et de l'opérateur ternaire dans l'autre, constitue 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 alternative.h✎

Contenu du fichier alternative.h

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

#ifndef ALTERNATIVE_H
#define ALTERNATIVE_H

double
sign_v1(double x);

double
sign_v2(double x);

double
signedSquare_v1(double x);

double
signedSquare_v2(double x);

int
delta_v1(int a,
         int b);

int
delta_v2(int a,
         int b);

#endif // ALTERNATIVE_H

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

Fichier alternative.c✎

Contenu du fichier alternative.c

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

#include "alternative.h"

double
sign_v1(double x)
{
  if(x<0.0)
  {
    return -1.0;
  }
  else
  {
    return 1.0;
  }
}

double
sign_v2(double x)
{
  return x<0.0 ? -1.0 : 1.0;
}

double
signedSquare_v1(double x)
{
  if(x<0.0)
  {
    return -x*x;
  }
  else
  {
    return x*x;
  }
}

double
signedSquare_v2(double x)
{
  return x<0.0 ? -x*x : x*x;
}

int
delta_v1(int a,
         int b)
{
  if(a<b)
  {
    return b-a;
  }
  else
  {
    return a-b;
  }
}

int
delta_v2(int a,
         int b)
{
  return a<b ? b-a : a-b;
}

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

Fichier prog_ex0201.c✎

Contenu du fichier prog_ex0201.c

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

#include "alternative.h"

#include <stdio.h>

void
test_sign(void)
{
  printf("\n~~~~ test_sign() ~~~~\n");
  const double x1=-2.3, x2=1.2;
  printf("v1: %g --> %g\n", x1, sign_v1(x1));
  printf("v1: %g --> %g\n", x2, sign_v1(x2));
  printf("v2: %g --> %g\n", x1, sign_v2(x1));
  printf("v2: %g --> %g\n", x2, sign_v2(x2));
}

void
test_signedSquare(void)
{
  printf("\n~~~~ test_signedSquare() ~~~~\n");
  const double x1=-2.3, x2=1.2;
  printf("v1: %g --> %g\n", x1, signedSquare_v1(x1));
  printf("v1: %g --> %g\n", x2, signedSquare_v1(x2));
  printf("v2: %g --> %g\n", x1, signedSquare_v2(x1));
  printf("v2: %g --> %g\n", x2, signedSquare_v2(x2));
}

void
test_delta(void)
{
  printf("\n~~~~ test_delta() ~~~~\n");
  const int a=5, b=8;
  printf("v1: %d, %d --> %d\n", a, b, delta_v1(a, b));
  printf("v1: %d, %d --> %d\n", b, a, delta_v1(b, a));
  printf("v2: %d, %d --> %d\n", a, b, delta_v2(a, b));
  printf("v2: %d, %d --> %d\n", b, a, delta_v2(b, a));
}

int
main(void)
{
  test_sign();
  test_signedSquare();
  test_delta();
  return 0;
}

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