How to implement 3 <= X <= 10 in C++?

Question

I want to be able to write

if (3 <= X <= 10)
{

}
else if (20 < X < 100) 
{ //...etc

in C++ and have it evaluate correctly. I know you can do this in Python and I think it's a very readable way to express a conditional.

I don't want to have to write:

if (3 <= X && X <= 10) //etc.

How can I do this in C++? Is it possible? What would overloading the operators look like? If not, could you explain why it's not possible?

Answer 1

Are you sure you need this?

[UPDATE]

After a while I come to an idea which even does not look totally crazy ;)

I made a working example at ideone

You need to start with wrapping of the first element:

int main() {
   int x = 134, y = 14;
   if (IntComp(7) <= x <= 134)
   {
       std::cout << "Hello ";
   } 
   if (IntComp(134) > y > 12)
   {
       std::cout << "world!";
   } 
}

The magic here:

class IntComp {
public:
   IntComp(int x, bool result = true) : value(x), result(result) {}
   IntComp operator <= (int x) const
   {
       return IntComp(x, result && value <= x);
   }
   IntComp operator > (int x) const
   {
       return IntComp(x, result && value > x);
   }
   operator bool() const { return result; }
private:
   int value;
   bool result;
};

Answer 2

You can't do this in C++. You have to break it up into two separate operations:

if (3 <= X && X <= 10)
{
    ...
}
else if (20 < X && X < 100)
{
    ...
}

Answer 3

Personally, I think all these operator overloading solutions are a bit over-engineered. How about two simple function templates instead?

template<typename A, typename B, typename C>
bool ordered(const A& a, const B& b, const C& c)
{
    return (a <= b) && (b <= c);
}

template<typename A, typename B, typename C>
bool between(const A& a, const B& b, const C& c)
{
    return (a < b) && (b < c);
}

void foobar(int X)
{
    if (ordered(3, X, 10))
    {

    }
    else if (between(20, X, 100))
    {
        // ...
    }
}

Answer 4

It is amazing, some of the things that C++ will let you do with user-defined types...

struct C
   {
   int value;
   bool state;
   C( int value, bool state=true ) : value(value), state(state) {}
   };

C operator <= ( int a, C b )
   {
   if ( a <= b.value ) return C(b.value,true);
   return C(b.value,false);
   }

bool operator <= ( C a, int b )
   {
   if ( a.state && a.value <= b ) return true;
   return false;
   }

std::ostream & operator << ( std::ostream & os, C c ) { os<<c.value; return os; }

void test( C X )
   {
   if (3 <= X <= 10) cerr<<"(3 <= X <= 10) is true for X="<<X<<"\n";
   }

int main()
   {
   test(2), test(3), test(4), test(10), test(11);
   }

Output...

$ ./how-to-implement-3-x-10-in-c++.cpp
(3 <= X <= 10) is true for X=3
(3 <= X <= 10) is true for X=4
(3 <= X <= 10) is true for X=10

Answer 5

The only way to do it is the way Marlon suggested. Unfortunately, there's no way to circumvent this with operator overloading. Overloading the operator would look like this: operator<=<=, where <=<= is a ternary operator. The only ternary operator is the "?:", and this would make your syntax look incredibly unsightly. Best to do it the old fashioned way.

Answer 6

Since C++11 with its range based for loop, the easiest and simplest is a Range class template that in addition to supporting the loop, supports set membership checking, e.g. as a method contains.

One obvious advantage is that with this approach there’s just one simple template, with multiple usages.

And a perhaps not so obvious advantage is that it supports having a const loop variable, like …

int main()
{
    using std::wcout;  using std::endl;  using cpp::range;

    for( auto const i : range( 2, 7 ) )
    {
        wcout << i << " ";
    }
    wcout << endl;

    if( range( 2, 7 ).contains( 3 ) )
    {
        wcout << "Yes!" << endl;
    }
    else
    {
        wcout << "No!" << endl;
    }
}

Definitions like e.g.

#include <utility>          // std::begin, std::end

namespace cpp {
    template< class Derived >
    class Comparable
    {
    public:
        friend bool operator<=( Derived const& a, Derived const& b )
        { return !(b < a); }

        friend bool operator>=( Derived const& a, Derived const& b )
        { return !(a < b); }

        friend bool operator>( Derived const& a, Derived const& b )
        { return (b < a); }

        friend bool operator!=( Derived const& a, Derived const& b )
        { return !(a == b); }
    };

    template< class TpValue >
    class Range
    {
    public:
        typedef TpValue Value;

    private:
        Value   first_;
        Value   last_;

    public:
        class Iter
            : public Comparable< Iter >
        {
        private:
            Value   current_;

        public:
            Value operator*() const { return current_; }

            void operator++() { ++current_; }

            friend bool operator<( Iter const a, Iter const b )
            { return a.current_ < b.current_; }

            friend bool operator==( Iter const a, Iter const b )
            { return a.current_ == b.current_; }

            explicit Iter( Value const v )
                : current_( v )
            {}
        };

        Value first() const { return first_; }
        Value last() const { return last_; }

        Iter begin() const { return Iter( first_ ); }
        Iter end() const { return Iter( last_ + 1 ); }

        bool contains( Value const x ) const
        { return (first_ <= x && x <= last_); }

        Range( Value const first, Value const last )
            : first_( first ), last_( last )
        {}
    };

    template< class Value >
    Range< Value > range( Value const first, Value const last )
    {
        return Range< Value >( first, last );
    }

    template< class Value >
    typename Range< Value >::Iter begin( Range< Value > const& r )
    { return r.begin(); }

    template< class Value >
    typename Range< Value >::Iter end( Range< Value > const& r )
    { return r.end(); }
}  // namespace cpp

Generalizing this to deal with floating point ranges is left as an exercise for the reader (it's not asked for here).

Answer 7

First of all: the Standard mandates that operator overloading involve at least one user-defined type in the arguments. Therefore X would have to be of a user-defined type.

If it is, then it becomes possible, no issue.

struct Integral {
    Integral(int i): _value(i) {}
    int _value;
};

class ComparisonResult {
public:
    ComparisonResult(Integral last, bool result): _last(last), _result(result) {}

    operator bool() const { return _result; }

    Integral last() const { return _last; }

private:
    Integral _last;
    bool _result;
};

ComparisonResult operator<(Integral left, integral right) {
    return ComparisonResult(right, left._value < right._value);
}

ComparisonResult operator<(ComparisonResult cr, Integral right) {
     if (not cr) { return ComparisonResult(right, false); }
     return ComparisonResult(right, cr.last() < right);
}

// Other operators here, with the same ComparisonResult type

And then:

int main() {
    Integral X(4);
    if (3 < X < 10) { std::cout << "Hello, World!\n"; }
}