Fonction MIN et MAX en C

Ce tutoriel discutera de l’utilisation de macros ou de boucles pour implémenter les fonctions MIN et MAX en C.

la fonction MIN et MAX en C

Les fonctions MIN et MAX permettent de trouver le nombre minimum et maximum à partir de deux valeurs et ne sont pas prédéfinies en langage C. Si on veut utiliser les fonctions MIN et MAX, il faut les définir en C.

On peut utiliser des macros pour définir les fonctions MIN et MAX en langage C. Une macro est un segment de code utilisé pour définir des valeurs et des fonctions variables.

Lorsque nous appelons une macro, elle est remplacée par sa valeur ou sa fonction. Par exemple, nous pouvons définir la valeur d’une variable comme PI, et lorsque nous utilisons le nom PI dans notre code, le nom sera remplacé par sa valeur.

On peut aussi définir une macro comme une fonction qui sera appelée si on écrit son nom dans le code. Nous utilisons le mot-clé #define pour définir des macros en langage C.

Par exemple, définissons les fonctions MIN et MAX à l’aide de macros en langage C. Voir le code ci-dessous.

#include <stdio.h>
#define MIN(i, j) (((i) < (j)) ? (i) : (j))
#define MAX(i, j) (((i) > (j)) ? (i) : (j))
int main() {
  printf("Min = %d\n", MIN(0, 10));
  printf("Max = %d", MAX(0, 10));
  return 0;
}

Production:

Min = 0
Max = 10

Dans le code ci-dessus, le ? Le symbole est l’opérateur ternaire et est utilisé à la place de l’instruction if-else. Si la condition avant l’opérateur ternaire est vraie, la sortie sera égale au côté gauche des deux-points :, et si la condition est fausse, la sortie sera égale au côté droit des deux-points :.

Dans le code ci-dessus, nous avons utilisé des crochets car l’entrée peut aussi être une expression comme a+b, et la sortie changera si nous n’utilisons pas de crochets. On peut aussi utiliser l’instruction if-else à la place de l’opérateur ternaire.

Le code ci-dessus créera des problèmes en cas d’effet secondaire de double évaluation dans lequel nous passons une expression à l’intérieur d’une fonction. Nous pouvons utiliser la commande __typeof__ pour définir les fonctions MIN et MAX pour éviter le problème ci-dessus, nous donnant plus de sécurité et moins de bogues.

La commande __typeof__ fait référence au type d’une expression. On peut utiliser la commande typeof avec des expressions et un type.

Par exemple, définissons les fonctions MIN et MAX ci-dessus à l’aide de la commande __typeof__. Voir le code ci-dessous.

#include <stdio.h>
#define MAX(x, y)       \
  ({                    \
    typeof(x) _x = (x); \
    typeof(y) _y = (y); \
    _x > _y ? _x : _y;  \
  })

#define MIN(x, y)       \
  ({                    \
    typeof(x) _x = (x); \
    typeof(y) _y = (y); \
    _x < _y ? _x : _y;  \
  })
int main() {
  printf("Min = %d\n", MIN(0, 10));
  printf("Max = %d", MAX(0, 10));
  return 0;
}

Production:

Min = 0
Max = 10

Dans le code ci-dessus, nous avons utilisé la commande __typeof__ pour faire référence au type des entrées, puis nous avons utilisé l’opérateur ternaire pour définir l’instruction if-else. Nous pouvons voir que la sortie est la même que dans l’exemple précédent.

Le code ci-dessus peut éviter le problème de la double évaluation car la macro ci-dessus n’évaluera les arguments qu’une seule fois. Les méthodes ci-dessus ne fonctionnent que dans le cas de deux entrées entières.

Si nous voulons trouver le nombre minimum et maximum présent dans un tableau de nombres, nous ne pouvons pas utiliser les méthodes ci-dessus car, dans les méthodes ci-dessus, nous ne comparons que deux nombres. Dans le cas d’un tableau, nous devons comparer tous les éléments ensemble pour trouver la valeur minimale ou maximale présente dans le tableau.

Nous pouvons stocker le premier élément du tableau dans une variable, puis nous pouvons utiliser une boucle pour comparer cet élément avec d’autres éléments du tableau.

Dans le cas du nombre maximum, si l’élément suivant est supérieur au prochain élément présent dans le tableau, cela signifie que l’élément qui est enregistré n’est pas l’élément maximum présent dans le tableau, et nous remplacerons l’élément enregistré par le suivant élément, et nous répéterons cette procédure jusqu’à ce que l’élément enregistré soit comparé à tous les éléments présents dans le tableau.

Dans le cas d’un nombre minimum, nous remplacerons l’élément enregistré par l’élément suivant uniquement si l’élément suivant est inférieur à l’élément enregistré, et nous répéterons cette procédure jusqu’à ce que l’élément enregistré soit comparé à tous les éléments présents dans le tableau.

#include <stdio.h>

int MAX(int My_array[], int len);
int MIN(int My_array[], int len);
int main() {
  int My_array[] = {6, 3, 15, 9, 10, 50, 99, 11};
  int len = sizeof(My_array) / sizeof(My_array[0]);
  int numMax = MAX(My_array, len);
  int numMin = MIN(My_array, len);
  printf("Max number = %d\n", numMax);
  printf("Min number = %d", numMin);
  return 0;
}

int MAX(int My_array[], int len) {
  int num = My_array[0];
  for (int i = 1; i < len; i++) {
    if (My_array[i] > num) {
      num = My_array[i];
    }
  }
  return num;
}

int MIN(int My_array[], int len) {
  int num = My_array[0];
  for (int i = 1; i < len; i++) {
    if (My_array[i] < num) {
      num = My_array[i];
    }
  }
  return num;
}

Production:

Max number = 99
Min number = 3

Dans le code ci-dessus, nous avons créé deux fonctions, MAX() et MIN(), qui ont deux arguments d’entrée. Le premier argument est le tableau donné et le second est la longueur du tableau.

Nous avons utilisé la fonction sizeof() pour trouver la taille du tableau entier et l’avons divisé par la taille du premier élément du tableau pour obtenir la longueur du tableau donné.

A l’intérieur de la fonction MAX() et MIN(), nous avons stocké le premier élément du tableau dans une variable, puis nous l’avons comparé avec tous les autres éléments du tableau à l’aide d’une boucle qui s’arrêtera lorsque l’entier i devient égal à la longueur du tableau, ce qui signifie que la boucle a atteint la fin du tableau.

À l’intérieur de la boucle, nous avons utilisé une instruction if pour comparer l’élément suivant du tableau avec la valeur que nous avons enregistrée, et nous avons remplacé sa valeur si l’élément suivant est supérieur à l’élément enregistré dans le cas de MAX() fonction, et dans la fonction MIN(), nous remplacerons la valeur si l’élément suivant est plus petit que l’élément enregistré. Nous avons utilisé la fonction printf() pour imprimer la valeur renvoyée par les fonctions MIN() et MAX().

Le code ci-dessus ne fonctionnera que pour un tableau d’un type de données entier, mais nous pouvons également modifier le code ci-dessus pour trouver les nombres minimum et maximum dans le cas d’autres types de données comme float. Dans le code ci-dessus, nous devons changer le type de données int en float dans le cas d’un tableau de types de données float.

Par exemple, le type de données du tableau deviendra float, et le type de données de la variable utilisée pour stocker le premier élément du tableau deviendra également float, et le type de données de la longueur restera le même.