C++11 conditional expression on std::greater and std::less got error of different types

Question

The following codes related to conditional expression:

typedef unsigned char uchar;
uchar data[100];
// assign something to array[] here
uchar *start = data;
uchar *end = data+100;
bool cond = f();  // f() could return true or false
uchar *itr = std::upper_bound(start, end, uchar(20), 
                cond? std::greater<uchar>() : std::less<uchar>());

got an error like this:

error: operands to ?: have different types 
‘std::greater<unsigned char>’ and ‘std::less<unsigned char>’

Is this a compiler bug? In my instinct, the two functor should have the same type.

Answer 1

std::greater and std::less are different types (just as different as std::string and std::unordered_map). They only provide same interface (operator()).

Conditional operator cond ? expr1 : expr2 requires, that expr1 and expr2 is of the same type (or one is implicitly convertible to another) and that is not your case.

You can use

char *itr;
if (cond)
    itr = std::upper_bound(start, end, uchar(20), std::greater<uchar>{});
else
    itr = std::upper_bound(start, end, uchar(20), std::less<uchar>{});

Or if you do not want to have two almost same lines, you can help yourself with generic lambda

auto upper_bound = [&](const auto& cmp){
    return std::upper_bound(start, end, uchar(20), cmp);
};
if (cond)
    itr = upper_bound(std::greater<uchar>{});
else
    itr = upper_bound(std::less<uchar>{});

Answer 2

Functors in C++ do not traditionally share a type. This makes it easy for the compiler to understand exactly which functor is being called, and causes a performance boost.

There is a mechanism in C++ called type erasure. This is where you forget what makes two types different, and only remembers what makes them the same.

The most common kind of type erasure in C++ is std::function. This function here type erases a stateless template that takes two T const& and returns a bool:

template<class T, template<class...>class Z>
std::function< bool(T const&, T const&) >
comp() { return Z<T>{}; }

we can then take your code and do this:

uchar *itr = std::upper_bound(start, end, uchar(20), 
            cond? comp<uchar, std::greater>() : comp<uchar, std::less>());

or alternatively:

template<class T>
using comp_sig = bool(T const&, T const&);

template<class T, template<class...>class Z>
comp_sig<T>* comp() {
  return [](T const& lhs, T const& rhs)->bool{
    return Z<T>{}(lhs, rhs);
  };
}

which gives you function pointers that call less or greater as required. This version might be slightly easier for compilers to optimize than the std::function one, as compilers are really good at optimizing constant function pointers.

Answer 3

Functors are just regular types. std::greater<uchar> is a completely different type from std:less<uchar>. Just like how std::vector<uchar> is different from std::set<uchar>, even though their properties are similar!

You can achieve what you want to achieve if you move your ternary operator a bit though:

char *itr = cond ?
    std::upper_bound(start, end, uchar(20), std::greater<uchar>()) :
    std::upper_bound(start, end, uchar(20), std::less<uchar>());

It's slightly more duplication, but just as readable and will compile.

Answer 4

I think it is not, as it is said it is different types. std::less is something like this :

template <class T>
struct Less
{
      bool operator()(const T & t1, const T & t2) ..
};

Answer 5

First, these two functors don't have the same type, even though they have same type of opetor(), which is, after template instantiation,

bool operator()(uchar lhs, uchar rhs)  

Similarly, just because vector<int> and deque<int> have same type of operator[] obviously doesn't mean they have the same type.

Back to your code, if you are able to use C++11, a simple & elegant solution is using lambda:

char *itr = std::upper_bound(start, end, uchar(20),  
            [cond](uchar lhs, uchar rhs) { return cond ? lhs > rhs : lhs < rhs); }

Otherwise, just writ a straightforward functor

class F{  
public:  
    explicit F(bool cond): m_cond(cond) {}
    bool operator(uchar lhs, uchar rhs) { return m_cond ? lhs > rhs : lhs < rhs); }  
private:
    bool m_cond;
};

Lastly, lambda is a pretty handy tool, I suggest you get to know more about it.
What is a lambda expression in C++11?
When to use functors over lambdas

Answer 6

Convert both of them to lambdas (non-capture, non-generic). In that case, their types are still different, but they both convert naturally to a plain old function pointer bool (*) (uchar, uchar) and therefore the ?: works

uchar *itr = std::upper_bound(start, end, uchar(20),
                 cond?
                 ([](uchar x, uchar y){return std::greater<uchar>{}(x,y);})
                 :
                 ([](uchar x, uchar y){return std::less   <uchar>{}(x,y);})
             );

(This works for me on clang 3.5 and g++ 5.3, but I'm not sure how portable this is. Should I use unary + to force the conversion to the function pointer?