MIN et MAX en C

Question

Où sont MIN y MAX définie en C, si elle existe ?

Quelle est la meilleure façon de les implémenter, de manière aussi générique et sûre que possible ? (De préférence, extensions de compilateurs ou buildins pour les compilateurs grand public).

Answer 1

Où sont MIN y MAX définie en C, si elle existe ?

Ils ne le sont pas.

Quelle est la meilleure façon de les implémenter, de la manière la plus générique et la plus sûre possible (extensions de compilateurs/compléments pour les compilateurs courants de préférence) ?

En tant que fonctions. Je n'utiliserais pas de macros comme #define MIN(X, Y) (((X) < (Y)) ? (X) : (Y)) surtout si vous envisagez de déployer votre code. Soit vous écrivez votre propre code, soit vous utilisez quelque chose comme le standard fmax o fmin ou corrigez la macro en utilisant Le type de GCC (vous bénéficiez également d'une prime de sécurité type) dans un centre d'hébergement. Expression de la déclaration GCC :

 #define max(a,b) \
   ({ __typeof__ (a) _a = (a); \
       __typeof__ (b) _b = (b); \
     _a > _b ? _a : _b; })

Tout le monde dit "oh, je connais la double évaluation, ce n'est pas un problème" et quelques mois plus tard, vous devrez déboguer les problèmes les plus stupides pendant des heures.

Notez l'utilisation de __typeof__ au lieu de typeof :

Si vous écrivez un fichier d'en-tête qui doit fonctionner lorsqu'il est inclus dans des programmes ISO C ISO, écrivez __typeof__ au lieu de typeof .

Answer 2

Il est également fourni dans les versions GNU libc (Linux) et FreeBSD de sys/param.h et a la définition fournie par dreamlax.

---

Sur Debian :

$ uname -sr
Linux 2.6.11

$ cat /etc/debian_version
5.0.2

$ egrep 'MIN\(|MAX\(' /usr/include/sys/param.h
#define MIN(a,b) (((a)<(b))?(a):(b))
#define MAX(a,b) (((a)>(b))?(a):(b))

$ head -n 2 /usr/include/sys/param.h | grep GNU
This file is part of the GNU C Library.

Sur FreeBSD :

$ uname -sr
FreeBSD 5.5-STABLE

$ egrep 'MIN\(|MAX\(' /usr/include/sys/param.h
#define MIN(a,b) (((a)<(b))?(a):(b))
#define MAX(a,b) (((a)>(b))?(a):(b))

---

Les dépôts de sources sont ici :

• Bibliothèque C de GNU
• FreeBSD

Answer 3

Il y a un std::min y std::max en C++, mais AFAIK, il n'y a pas d'équivalent dans la bibliothèque standard du C. Vous pouvez les définir vous-même avec des macros comme

#define MAX(x, y) (((x) > (y)) ? (x) : (y))
#define MIN(x, y) (((x) < (y)) ? (x) : (y))

Mais cela pose des problèmes si vous écrivez quelque chose comme MAX(++a, ++b) .

Answer 4

Je ne pense pas qu'il s'agisse de macros standardisées. Il existe déjà des fonctions standardisées pour la virgule flottante, fmax y fmin (et fmaxf pour les flotteurs, et fmaxl pour les doubles longs).

Vous pouvez les mettre en œuvre sous forme de macros, à condition d'être conscient des problèmes d'effets secondaires et de double évaluation.

#define MAX(a,b) ((a) > (b) ? a : b)
#define MIN(a,b) ((a) < (b) ? a : b)

Dans la plupart des cas, vous pouvez laisser au compilateur le soin de déterminer ce que vous essayez de faire et de l'optimiser du mieux qu'il peut. Bien que cela pose des problèmes lorsqu'il est utilisé comme MAX(i++, j++) Je doute qu'il soit nécessaire de vérifier le maximum de valeurs incrémentées en une seule fois. Incrémentez d'abord, puis vérifiez.

Answer 5

J'ai écrit ceci version qui fonctionne pour MSVC, GCC, C et C++.

#if defined(__cplusplus) && !defined(__GNUC__)
#   include <algorithm>
#   define MIN std::min
#   define MAX std::max
//#   define TMIN(T, a, b) std::min<T>(a, b)
//#   define TMAX(T, a, b) std::max<T>(a, b)
#else
#       define _CHOOSE2(binoper, lexpr, lvar, rexpr, rvar) \
                ({ \
                        decltype(lexpr) lvar = (lexpr); \
                        decltype(rexpr) rvar = (rexpr); \
                        lvar binoper rvar ? lvar : rvar; \
                })
#       define _CHOOSE_VAR2(prefix, unique) prefix##unique
#       define _CHOOSE_VAR(prefix, unique) _CHOOSE_VAR2(prefix, unique)
#       define _CHOOSE(binoper, lexpr, rexpr) \
                _CHOOSE2( \
                        binoper, \
                        lexpr, _CHOOSE_VAR(_left, __COUNTER__), \
                        rexpr, _CHOOSE_VAR(_right, __COUNTER__) \
                )
#       define MIN(a, b) _CHOOSE(<, a, b)
#       define MAX(a, b) _CHOOSE(>, a, b)
#endif