Function "between" for "Everything in One Line" library

Question

This is a function to determine if a number is between x and y. It is part of a library of mine called EOL or "Everything in One Line".

#include <stdbool.h>

#ifndef _WINDOWS_H
    #include <windows.h>
#endif

bool between (WORD n, WORD x, WORD y) { return (n >= x && n <= y) ? (true) : (false); }

Answer 1

There's no need to use the conditional operator here. This would be enough:

bool between (WORD n, WORD x, WORD y) { 
    return n >= x && n <= y;
}

Other than this, the variable names are not descriptive. It is not clear that x specifies the lower bound and y the higher bound.

bool between (WORD value, WORD low, WORD high) { 
    return value >= low && value <= high;
}

Additionally, I have to question a little bit the usage for a "Everything in One Line" library. If the code that you are writing is trivial one-liners, it might be easier for other programmers to quickly re-write the actual code than to use your library. Most of the times I could use a between function, I would probably write the actual code in-line, without using an additional function for it at all. However, writing a "Everything in One Line"-library can of course be an educating experience for yourself.

Answer 2

Strictly speaking, you only need to #include <windef.h> here, though including all of <windows.h> is harmless. The #ifndef shouldn't be necessary in either case, as each included header should be responsible for guarding against its own double-inclusion.

Answer 3

The parentheses around the true and false are superfluous. It makes no difference to the compiler and doesn't really improve the readability here. It may be warranted if the expressions were somewhat more complex.

Answer 4

There is no reason to include windows.h at all, as there is nothing Windows-specific in this code (aside from the WORD type, which is not really a good way to do things in this day and age).

Doing such things as macros is dangerous and unnecessary; parameters aren't necessarily single values without side effects. And if it's in a header or if your compiler supports link-time optimization, the compiler can optimize it into an inline anyway. The only thing a macro buys you in this case is type-independence but it's not doing it in a particularly safe way here, and you're specifying the type in the macro so you lose that as well.

You might want to improve the condition to allow for the extents to be in any order, e.g.:

static bool between(int n, int x, int y) {
    return (x <= n && n <= y) || (y <= n && n <= x);
}

(static bool is if this implementation is kept in a header, so that non-optimizing compilers won't have multiple instances of the same symbol at link time.)

And, finally, for something so simple and obvious as this, it's not really necessary to put into a library.

Answer 5

between (WORD n, WORD x, WORD y)

In languages that have such a comparison built in, the order of operands would be x <= n <= y. Is there a reason you chose NXY instead of XNY for your parameter order?