Is there a shorter way to write compound 'if' conditions? [duplicate]

Answer 1

For this specific case you can use the fact that char is an integer and test for a range:

if(ch >= 'A' && ch <= 'C')
{
    ...
}

But in general this is not possible unfortunately. If you want to compress your code just use a boolean function

if(compare_char(ch))
{
    ...
}

Answer 2

Templates allow us to express ourselves in this way:

if (range("A-F").contains(ch)) { ... }

It requires a little plumbing, which you can put in a library.

This actually compiles out to be incredibly efficient (at least on gcc and clang).

#include <cstdint>
#include <tuple>
#include <utility>
#include <iostream>

namespace detail {
    template<class T>
    struct range
    {
        constexpr range(T first, T last)
        : _begin(first), _end(last)
        {}

        constexpr T begin() const { return _begin; }
        constexpr T end() const { return _end; }

        template<class U>
        constexpr bool contains(const U& u) const
        {
            return _begin <= u and u <= _end;
        }

    private:
        T _begin;
        T _end;
    };

    template<class...Ranges>
    struct ranges
    {
        constexpr ranges(Ranges...ranges) : _ranges(std::make_tuple(ranges...)) {}

        template<class U>
        struct range_check
        {
            template<std::size_t I>
            bool contains_impl(std::integral_constant<std::size_t, I>,
                               const U& u,
                               const std::tuple<Ranges...>& ranges) const
            {
                return std::get<I>(ranges).contains(u)
                or contains_impl(std::integral_constant<std::size_t, I+1>(),u, ranges);
            }

            bool contains_impl(std::integral_constant<std::size_t, sizeof...(Ranges)>,
                               const U& u,
                               const std::tuple<Ranges...>& ranges) const
            {
                return false;
            }


            constexpr bool operator()(const U& u, std::tuple<Ranges...> const& ranges) const
            {
                return contains_impl(std::integral_constant<std::size_t, 0>(), u, ranges);
            }
        };

        template<class U>
        constexpr bool contains(const U& u) const
        {
            range_check<U> check {};
            return check(u, _ranges);
        }

        std::tuple<Ranges...> _ranges;
    };
}

template<class T>
constexpr auto range(T t) { return detail::range<T>(t, t); }

template<class T>
constexpr auto range(T from, T to) { return detail::range<T>(from, to); }

// this is the little trick which turns an ascii string into
// a range of characters at compile time. It's probably a bit naughty
// as I am not checking syntax. You could write "ApZ" and it would be
// interpreted as "A-Z".
constexpr auto range(const char (&s)[4])
{
    return range(s[0], s[2]);
}

template<class...Rs>
constexpr auto ranges(Rs...rs)
{
    return detail::ranges<Rs...>(rs...);
}

int main()
{
    std::cout << range(1,7).contains(5) << std::endl;
    std::cout << range("a-f").contains('b') << std::endl;

    auto az = ranges(range('a'), range('z'));
    std::cout << az.contains('a') << std::endl;
    std::cout << az.contains('z') << std::endl;
    std::cout << az.contains('p') << std::endl;

    auto rs = ranges(range("a-f"), range("p-z"));
    for (char ch = 'a' ; ch <= 'z' ; ++ch)
    {
        std::cout << ch << rs.contains(ch) << " ";
    }
    std::cout << std::endl;

    return 0;
}

expected output:

1
1
1
1
0
a1 b1 c1 d1 e1 f1 g0 h0 i0 j0 k0 l0 m0 n0 o0 p1 q1 r1 s1 t1 u1 v1 w1 x1 y1 z1 

For reference, here was my original answer:

template<class X, class Y>
bool in(X const& x, Y const& y)
{
    return x == y;
}

template<class X, class Y, class...Rest>
bool in(X const& x, Y const& y, Rest const&...rest)
{
    return in(x, y) or in(x, rest...);
}

int main()
{
    int ch = 6;
    std::cout << in(ch, 1,2,3,4,5,6,7) << std::endl;

    std::string foo = "foo";
    std::cout << in(foo, "bar", "foo", "baz") << std::endl;

    std::cout << in(foo, "bar", "baz") << std::endl;
}

Answer 3

strchr() can be used to see if the character is in a list.

const char* list = "ABCXZ";
if (strchr(list, ch)) {
  // 'ch' is 'A', 'B', 'C', 'X', or 'Z'
}

Answer 4

Similarly to the C strchr answer, In C++ you can construct a string and check the character against its contents:

#include <string>
...
std::string("ABCDEFGIKZ").find(c) != std::string::npos;

The above will return true for 'F' and 'Z' but false for 'z' or 'O'. This code does not assume contiguous representation of characters.

This works because std::string::find returns std::string::npos when it can't find the character in the string.

^{Live on Coliru}

Edit:

There's another C++ method which doesn't involve dynamic allocation, but does involve an even longer piece of code:

#include <algorithm> // std::find
#include <iterator> // std::begin and std::end
...
char const chars[] = "ABCDEFGIKZ";
return std::find(std::begin(chars), std::end(chars), c) != std::end(chars);

This works similarly to the first code snippet: std::find searches the given range and returns a specific value if the item isn't found. Here, said specific value is the range's end.

^{Live on Coliru}

Answer 5

One option is the unordered_set. Put the characters of interest into the set. Then just check the count of the character in question:

#include <iostream>
#include <unordered_set>

using namespace std;

int main() {
  unordered_set<char> characters;
  characters.insert('A');
  characters.insert('B');
  characters.insert('C');
  // ...

  if (characters.count('A')) {
    cout << "found" << endl;
  } else {
    cout << "not found" << endl;
  }

  return 0;
}

Answer 6

Most of the terse versions have been covered, so I will cover the optimized cases with some helper macros to make them a little more terse.

It just so happens that if your range falls within your number of bits per long that you can combine all of your constants using a bitmask and just check that your value falls in the range and the variable's bitmask is non-zero when bitwise-anded with the constant bitmask.

/* This macro assumes the bits will fit in a long integer type,
 * if it needs to be larger (64 bits on x32 etc...),
 * you can change the shifted 1ULs to 1ULL or if range is > 64 bits,
 * split it into multiple ranges or use SIMD
 * It also assumes that a0 is the lowest and a9 is the highest,
 * You may want to add compile time assert that:
 * a9 (the highest value) - a0 (the lowest value) < max_bits
 * and that a1-a8 fall within a0 to a9
 */
#define RANGE_TO_BITMASK_10(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9) \
  (1 | (1UL<<((a1)-(a0))) | (1UL<<((a2)-(a0))) | (1UL<<((a3)-(a0))) | \
  (1UL<<((a4)-(a0))) | (1UL<<((a5)-(a0))) | (1UL<<((a6)-(a0))) | \
  (1UL<<((a7)-(a0))) | (1UL<<((a8)-(a0))) | (1UL<<((a9)-(a0))) )

/*static inline*/ bool checkx(int x){
    const unsigned long bitmask = /* assume 64 bits */
        RANGE_TO_BITMASK_10('A','B','C','F','G','H','c','f','y','z');
    unsigned temp = (unsigned)x-'A';
    return ( ( temp <= ('z'-'A') ) && !!( (1ULL<<temp) & bitmask ) );
}

Since all of a# values are constants, they will be combined into 1 bitmask at compile time. That leaves 1 subtraction and 1 compare for the range, 1 shift and 1 bitwise and ... unless the compiler can optimize further, it turns out clang can (it uses the bit test instruction BTQ):

checkx:                                 # @checkx
        addl    $-65, %edi
        cmpl    $57, %edi
        ja      .LBB0_1
        movabsq $216172936732606695, %rax # imm = 0x3000024000000E7
        btq     %rdi, %rax
        setb    %al
        retq
.LBB0_1:
        xorl    %eax, %eax
        retq

It may look like more code on the C side, but if you are looking to optimize, this looks like it may be worth it on the assembly side. I'm sure someone could get creative with the macro to make it more useful in a real programming situations than this "proof of concept".

That will get a little complex as a macro, so here is an alternative set of macros to setup a C99 lookup table.

#include <limits.h>
#define INIT_1(v,a) [ a ] = v
#define INIT_2(v,a,...) [ a ] = v, INIT_1(v, __VA_ARGS__)
#define INIT_3(v,a,...) [ a ] = v, INIT_2(v, __VA_ARGS__)
#define INIT_4(v,a,...) [ a ] = v, INIT_3(v, __VA_ARGS__)
#define INIT_5(v,a,...) [ a ] = v, INIT_4(v, __VA_ARGS__)
#define INIT_6(v,a,...) [ a ] = v, INIT_5(v, __VA_ARGS__)
#define INIT_7(v,a,...) [ a ] = v, INIT_6(v, __VA_ARGS__)
#define INIT_8(v,a,...) [ a ] = v, INIT_7(v, __VA_ARGS__)
#define INIT_9(v,a,...) [ a ] = v, INIT_8(v, __VA_ARGS__)
#define INIT_10(v,a,...) [ a ] = v, INIT_9(v, __VA_ARGS__)
#define ISANY10(x,...) ((const unsigned char[UCHAR_MAX+1]){ \
                          INIT_10(-1, __VA_ARGS__) \
                       })[x]

bool checkX(int x){
  return ISANY10(x,'A','B','C','F','G','H','c','f','y','z');
}

This method will use a (typically) 256 byte table and a lookup that reduces to something like the following in gcc:

checkX:
        movslq  %edi, %rdi  # x, x
        cmpb    $0, C.2.1300(%rdi)      #, C.2
        setne   %al   #, tmp93
        ret

NOTE: Clang doesn't fare as well on the lookup table in this method because it sets up const tables that occur inside functions on the stack on each function call, so you would want to use INIT_10 to initialize a static const unsigned char [UCHAR_MAX+1] outside of the function to achieve similar optimization to gcc.