Pfthb

Apologies in advance. I'm having a bit of difficulty finding the right phrasing for this question...

As an exercise, I'm working on a fixed-size priority queue that throws away objects greater than the max (for a queue finding the X smallest object) and throws away objects less than min (for queue holding the largest X objects). The question is whether there is way of arriving at the logical "opposite" of the comparator at compile-time.

See commented line in the code below:

template <
 typename T, 
 typename Container = std::vector<T>, 
 typename Compare = std::less<typename Container::value_type>>
class fixed_size_priority_queue : public std::priority_queue<T, Container, Compare>

 typename Container::size_type maxSize;
 using base = std::priority_queue<T, Container, Compare>;

 public:
 fixed_size_priority_queue(std::size_t size) : base(), maxSize(size)
 
 base::c.reserve(size);
 
 void push(T value)
 
 if (base::size() < maxSize)
 
 base::push(value);
 
 // is there some way of arriving at compile-time opposite of 'comp'?
 else if (!base::comp(base::top(), value))
 
 while (base::size() >= maxSize)
 
 base::pop();
 
 base::push(value);
 
 
;

void test_fixedPriQueue()


 using smallestInts = fixed_size_priority_queue<int>;
 smallestInts fq(4);
 fq.push(5);
 fq.push(3);
 fq.push(5);
 fq.push(5);
 fq.push(7);
 fq.push(11);
 fq.push(1);
 fq.push(2);


int main(int argc, char const *argv)

 test_fixedPriQueue();
 return 0;

I've simply used the not (!) operator to get the job done, but would this incur an, albeit very small, runtime cost? Is there a way to arrive at std::greater_equal when my class uses Compare = std::less?

I was hoping to use something like std::not<Compare> which would resolve to std::greater_equal when the Compare template parameter is std::less. Does that make sense?

** edit **

Trying the suggestion from sergeyA yielded what I was looking for:

template<typename T, typename Comparison>
struct logical_opposite

 using op = void;
;

template <typename T>
struct logical_opposite<T, std::less<T>>

 using op = std::greater_equal<T>;
;

template <typename T>
struct logical_opposite<T, std::greater<T>>

 using op = std::less_equal<T>;
;

Then in the class derived from priority_queue, instantiate the logical opposite function object and use it when pushing into the queue:

//...
typename logical_opposite<T, Compare>::op not_comp;

public:
fixed_size_priority_queue(std::size_t size) : base(), maxSize(size), not_comp()
//....

There is a logical relationship between the comparison functor types and I was hoping that relationship was expressed in the STL.

There is no observable difference between !< and >= on primitive types, so your fear of a runtime cost is ungrounded.

C++ is not assembly. It describes the behaviour of an abstract machine. Compilers map this to assembly, and operations that have no observable difference can be implemented identically in assembly.

While it takes some experience to learn what is "observable" in C++, the general rule is write clean code that avoids allocations when reasonable, keep da contiguous and keep O-notation speed sane, then test programs for performance problems before you worry about other issues.

!< vs >= is not one of the "avoid premature pessimisation" issues, so you should ignore it unless you find the code when profiling.