Implementing min() and max() in Clang without double evaluation

Question

The classic preprocessor version of the min function looks like

#define min(a, b) ((a) < (b) ? (a) : (b))

This leaves you open to double evaluation—the situation in which you do min(f(), g()), forgetting that f or g has side effects, and you have to spend hours trying to figure out why your function is running twice. To prevent this, you can do

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

This works great under GCC, but if you run it through Clang with -Wgnu set—this set of warnings falls under the umbrella of -pedantic—you get errors like

test.c:5:10: error: use of GNU statement expression extension [-Werror,-Wgnu]
        int a = min(3, 7);
                ^
test.c:1:22: note: expanded from macro 'min'
#  define min(a, b) ({__typeof__(a) _a = (a); __typeof__(b) _b = (b); _a < _b ? _a : _b;})

Is it possible to define these macros in a way that prevents double evaluation and which is acceptable to Clang under -pedantic? (Yes, you can disable the warning with -Wno-gnu, in which case Clang handles the statement expression without a problem. I’m asking because I, like clang -pedantic, am too picky for my own good.)

Edit: I am working in C. I tagged this C++ too because I thought a solution might apply to C++ as well as to C. Oops—forgot about templates! Sorry for the ambiguity.

I am curious why both C and C++ tags, which language are you targetting? The answer is different depending on the language. — Shafik Yaghmour
– Shafik Yaghmour, Commented Dec 18, 2013 at 15:19
Simply don't use the preprocessor for it, period. An inline function does the job better and in a more obvious way. And I think in C++ you can even use templates to avoid creating multiple functions for different types. — ThiefMaster
– ThiefMaster, Commented Dec 18, 2013 at 15:19
Why is a C++ answer accepted for this question, where you clearly state that you want C and a C version exists? — Jens Gustedt
– Jens Gustedt, Commented Dec 18, 2013 at 16:43
@bdesham, I don't understand, the link doesn't add much to what you already had in your question. Can you elaborate, please, why the C answer is less satisfactory? As it appears now, this is a C++ answer to a C question, so it will not serve many others. — Jens Gustedt
– Jens Gustedt, Commented Dec 18, 2013 at 17:04
@bdesham it is boilerplate that you only have to write once though. — Simple
– Simple, Commented Dec 18, 2013 at 18:15

Community · Accepted Answer · 2017-05-23 11:54:04Z

13

If you're really writing in C++, simply don't use the preprocessor:

template <typename T>
const T min(const T& a, const T& b)
{
   return (b < a) ? b : a;
}

^{(Note that I've swapped b and a, so that you get the left-hand operand if the two are equal.)}

Otherwise no, not really.

edited May 23, 2017 at 11:54

CommunityBot

11 silver badge

answered Dec 18, 2013 at 15:19

Lightness Races in Orbit

387k77 gold badges670 silver badges1.1k bronze badges

Sign up to request clarification or add additional context in comments.

12 Comments

Lightness Races in Orbit Over a year ago

@Lundin: Because the < operator does not pick one of two operands. It gives you a boolean. Show us your genius C solution.

Oliver Charlesworth Over a year ago

Here is an article where Andrei Alexandrescu gets very het up about the correct way to write a min/max function template: drdobbs.com/generic-min-and-max-redivivus/184403774.

Jens Gustedt Over a year ago

Even as a C++ answer this isn't a good one, since this doesn't capture the case that a and b may have different types.

Lundin Over a year ago

@bdesham If you are using C then 1) why tag it as C++ and 2) why accept a C++ answer. You don't make any sense.

Lundin Over a year ago

It is written in C++ and will not compile in C.

|

Simple · Accepted Answer · 2013-12-18 18:08:56Z

8

I think this would work as a C11 solution.

inline
int min(int const x, int const y)
{
    return y < x ? y : x;
}

inline
unsigned minu(unsigned const x, unsigned const y)
{
    return y < x ? y : x;
}

inline
long minl(long const x, long const y)
{
    return y < x ? y : x;
}

inline
unsigned long minul(unsigned long const x, unsigned long const y)
{
    return y < x ? y : x;
}

inline
long long minll(long long const x, long long const y)
{
    return y < x ? y : x;
}

inline
unsigned long long minull(unsigned long long const x, unsigned long long const y)
{
    return y < x ? y : x;
}

inline
float minf(float const x, float const y)
{
    return y < x ? y : x;
}

inline
double mind(double const x, double const y)
{
    return y < x ? y : x;
}

inline
long double minld(long double const x, long double const y)
{
    return y < x ? y : x;
}

#define MIN(X, Y) (_Generic((X) + (Y),   \
    int:                min,             \
    unsigned:           minu,            \
    long:               minl,            \
    unsigned long:      minul,           \
    long long:          minll,           \
    unsigned long long: minull,          \
    float:              minf,            \
    double:             mind,            \
    long double:        minld)((X), (Y)))

edited Dec 18, 2013 at 18:08

answered Dec 18, 2013 at 16:22

Simple

14.5k2 gold badges51 silver badges50 bronze badges

4 Comments

Jens Gustedt Over a year ago

+1 but your _Generic expression is much too complicated. _Generic((X)+(Y), int : min, unsigned : minu, ...)((X), (Y)) would suffice. Also you have forgotten the floating point types.

Simple Over a year ago

@JensGustedt thanks. I don't think there's a way to get this to work for pointers though without requiring a void* cast.

Jens Gustedt Over a year ago

Pointers could be done through a default case, only that the choice expression as it is now wouldn't work for pointers :(

Simple Over a year ago

@JensGustedt I think you'd lose the nicer error message then though if you tried to pass a struct or something.

Lundin · Accepted Answer · 2013-12-19 12:32:47Z

The C11 solution posted by Simple looks ideal, but in case you don't have a C11 compiler, you could still define a macro with intristic type safety (as type safe as C gets anyhow) :

#define MIN(type, X, Y) min_ ## type(X, Y)

This macro will only allow implemented types to be passed, otherwise you will get a compiler error.

Example:

#define MIN(type, X, Y) min_ ## type(X, Y)

long  min_long  (long x, long y);
char  min_char  (char x, char y);
float min_float (float x, float y);

int main()
{
  long  min_l = MIN (long, 5L, 10L);
  char  min_c = MIN (char, 'A', 'B');
  float min_f = MIN (float, 666.66f, 3.14f);

  printf("%ld\n", min_l);
  printf("%c\n", min_c);
  printf("%f\n", min_f);
}

char  min_char  (char x, char y)    { return x < y ? x : y; }
long  min_long  (long x, long y)    { return x < y ? x : y; }
float min_float (float x, float y)  { return x < y ? x : y; }

Now if you would execute the above macro with MIN(int, 1, 2), you would get a compiler error: "min_int, no such function exists".

Collectives™ on Stack Overflow

Implementing min() and max() in Clang without double evaluation

3 Answers 3

12 Comments

4 Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

12 Comments

4 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related