ENIB LANG-C Ex_0202 - Opérateurs logiques

{1} Première variante

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

elle attend deux paramètres de type entier,
elle fournit un résultat de type booléen,
si les paramètres sont tous les deux pairs ou bien s'ils sont tous les deux impairs, alors le résultat doit être vrai, sinon il doit être faux,
elle doit reposer sur la combinaison d'opérateurs logiques comme et, ou, non.

Indication :

L'expression (a%2) (reste de la division entière de a par 2) est vraie si l'entier a est impair.

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

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

qui sera appelée depuis la fonction main().
Elle doit être complétée en déclarant quelques variables entières initialisées pour constater le bon fonctionnement de la fonction réalisée.
Il faudra les afficher ainsi que le résultat de la fonction sameParity() qui leur sera appliquée.

{2} Deuxième variante

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

elle attend deux paramètres de type entier,
elle fournit un résultat de type booléen,
si l'un des deux paramètres est pair mais que l'autre est impair, alors le résultat doit être vrai, sinon il doit être faux,
elle doit reposer sur la combinaison d'opérateurs logiques comme et, ou, non.

Indication :

L'expression (a%2) (reste de la division entière de a par 2) est vraie si l'entier a est impair.

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

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

{3} Troisième variante

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

elle attend trois paramètres de type réel,
elle fournit un résultat de type booléen,
si la valeur du deuxième paramètre est comprise entre celles du premier et du troisième, alors le résultat doit être vrai, sinon il doit être faux,
(les trois paramètres peuvent aussi bien être énumérés dans l'ordre croissant que décroissants)
elle doit reposer sur la combinaison d'opérateurs logiques comme et, ou, non.

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

void
test_ordered(void)
{
  printf("\n~~~~ test_ordered() ~~~~\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 ainsi que le résultat de la fonction ordered() qui leur sera appliquée.
Par exemple :

pour les valeurs 1.1, 2.2 et 3.3 le résultat doit être vrai,
pour les valeurs 3.3, 2.2 et 1.1 le résultat doit également être vrai,
pour les valeurs 2.2, 1.1 et 3.3 le résultat doit être faux,
...

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 des opérateurs logiques constitue l'essentiel de l'exercice ; il n'est pas question de recourir à une formulation alternative qui produirait malgré tout un résultat équivalent✍
Dans le cas présent, une autre formulation serait probablement meilleure, mais ce n'est pas l'objet de cette question.
.

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 logical.h✎

Contenu du fichier logical.h

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

#ifndef LOGICAL_H
#define LOGICAL_H

#include <stdbool.h>

bool
sameParity(int x1,
           int x2);

bool
oppositeParity(int x1,
               int x2);

bool
ordered(double x1,
        double x2,
        double x3);

#endif // LOGICAL_H

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

Fichier logical.c✎

Contenu du fichier logical.c

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

#include "logical.h"

bool
sameParity(int x1,
           int x2)
{
  // return (x1%2)==(x2%2); // correct but _no_ logical operation involved
  return ((x1%2) && (x2%2)) || (!(x1%2) && !(x2%2));
}

bool
oppositeParity(int x1,
               int x2)
{
  // return (x1%2)!=(x2%2); // correct but _no_ logical operation involved
  return ((x1%2) && !(x2%2)) || (!(x1%2) && (x2%2));
}

bool
ordered(double x1,
        double x2,
        double x3)
{
  return ((x1<=x2) && (x2<=x3)) || ((x3<=x2) && (x2<=x1));
}

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

Fichier prog_ex0202.c✎

Contenu du fichier prog_ex0202.c

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

#include "logical.h"

#include <stdio.h>

void
test_sameParity(void)
{
  printf("\n~~~~ test_sameParity() ~~~~\n");
  const int i1=5, i2=8, i3=11, i4=16;
  printf("%d %d --> %d\n", i1, i2, sameParity(i1, i2));
  printf("%d %d --> %d\n", i1, i3, sameParity(i1, i3));
  printf("%d %d --> %d\n", i2, i3, sameParity(i2, i3));
  printf("%d %d --> %d\n", i2, i4, sameParity(i2, i4));
}

void
test_oppositeParity(void)
{
  printf("\n~~~~ test_oppositeParity() ~~~~\n");
  const int i1=5, i2=8, i3=11, i4=16;
  printf("%d %d --> %d\n", i1, i2, oppositeParity(i1, i2));
  printf("%d %d --> %d\n", i1, i3, oppositeParity(i1, i3));
  printf("%d %d --> %d\n", i2, i3, oppositeParity(i2, i3));
  printf("%d %d --> %d\n", i2, i4, oppositeParity(i2, i4));
}

void
test_ordered(void)
{
  printf("\n~~~~ test_ordered() ~~~~\n");
  const double a=1.1, b=2.2, c=3.3;
  printf("%g %g %g --> %d\n", a, b, c, ordered(a, b, c));
  printf("%g %g %g --> %d\n", c, b, a, ordered(c, b, a));
  printf("%g %g %g --> %d\n", b, a, c, ordered(b, a, c));
}

int
main(void)
{
  test_sameParity();
  test_oppositeParity();
  test_ordered();
  return 0;
}

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