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

Answer 1

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 
#include 
#include 
#include 

namespace detail {
    template
    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
        constexpr bool contains(const U& u) const
        {
            return _begin <= u and u <= _end;
        }

    private:
        T _begin;
        T _end;
    };

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

        template
        struct range_check
        {
            template
            bool contains_impl(std::integral_constant,
                               const U& u,
                               const std::tuple& ranges) const
            {
                return std::get(ranges).contains(u)
                or contains_impl(std::integral_constant(),u, ranges);
            }

            bool contains_impl(std::integral_constant,
                               const U& u,
                               const std::tuple& ranges) const
            {
                return false;
            }


            constexpr bool operator()(const U& u, std::tuple const& ranges) const
            {
                return contains_impl(std::integral_constant(), u, ranges);
            }
        };

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

        std::tuple _ranges;
    };
}

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

template
constexpr auto range(T from, T to) { return detail::range(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
constexpr auto ranges(Rs...rs)
{
    return detail::ranges(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
bool in(X const& x, Y const& y)
{
    return x == y;
}

template
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;
}