//в системных хедерах
typedef unsigned short WORD;

//свой код
typedef std::map<std::string, WORD> Values;

struct Less {
    bool operator()(Values::value_type const& left
    , Values::value_type const& right) const {
       if (right.second == TEMPERATURE_UNKNOWN 
          || left.second == TEMPERATURE_UNKNOWN) {
             return false;
       }
       short const signed_left = *reinterpret_cast<short const*>(&left.second);
       short const signed_right = *reinterpret_cast<short const*>(&right.second);
       bool const result = signed_left < signed_right;
       return result;
    }
};

short const signed_left = *reinterpret_cast<short const*>(&left.second);

#include <iostream>

#include <algorithm>

#include <vector>

#include <map>

 

unsigned short INVALID = 0x7FFF;

 

struct less

{

    bool operator() (std::map<int, unsigned short>::value_type const& a, std::map<int, unsigned short>::value_type const& b)

    {

        if (a.second == INVALID || b.second == INVALID)

            return false;

        return a.second < b.second;

    }

};

 

int main()

{

        std::map<int, unsigned short> a;

        a[1] = INVALID;

        a[2] = 1;

        a[3] = 2;

        a[4] = 3;

    std::cout << "A max = " << std::max_element(a.begin(), a.end(), less())->second << std::endl;

    std::cout << "A min = " << std::min_element(a.begin(), a.end(), less())->second<< std::endl;

 

    std::map<int, unsigned short> b;

        b[1] = 1;

        b[2] = 2;

        b[3] = 3;

        b[4] = INVALID;

    std::cout << "B max = " << std::max_element(b.begin(), b.end(), less())->second << std::endl;

    std::cout << "B min = " << std::min_element(b.begin(), b.end(), less())->second << std::endl;

 

 

    return 0;

}

25.4 Sorting and related operations
...
3 For all algorithms that take Compare, there is a version that uses operator< instead. That is, comp(*i,
*j) != false defaults to *i < *j != false. For algorithms other than those described in 25.4.3 to work
correctly, comp has to induce a strict weak ordering on the values.
4 The term strict refers to the requirement of an irreflexive relation (!comp(x, x) for all x), and the term weak
to requirements that are not as strong as those for a total ordering, but stronger than those for a partial
ordering. If we define equiv(a, b) as !comp(a, b) && !comp(b, a), then the requirements are that comp
and equiv both be transitive relations:
(4.1) — comp(a, b) && comp(b, c) implies comp(a, c)
(4.2) — equiv(a, b) && equiv(b, c) implies equiv(a, c) [Note: Under these conditions, it can be shown
that
(4.2.1) — equiv is an equivalence relation
(4.2.2) — comp induces a well-defined relation on the equivalence classes determined by equiv
(4.2.3) — The induced relation is a strict total ordering. —end note

short const signed_left = *(short const*)(&left.second);

    bool operator() (std::map<int, unsigned short>::value_type const& a, std::map<int, unsigned short>::value_type const& b)
    {
        if ((a.second == INVALID) && (b.second == INVALID))
            return false;
        if(a.second == INVALID)  
                return true;
        if(b.second == INVALID)  
                return false;            
        return a.second < b.second;
    }

DA>short const signed_left = *reinterpret_cast<short const*>(&left.second);
DA>

short const signed_left = static_cast<short>(left.second);

Antisymmetry f(x, y) implies !f(y, x)

In mathematics an asymmetric relation is a binary relation on a set X where:

For all a and b in X, if a is related to b, then b is not related to a.[1]

bool operator() (optional a, optional b) const {
    bool a_null = is_null(a);
    bool b_null = is_null(b);
    if(a_null != b_null) return a_null; // или b_null чтобы в конец
    return !a_null && value(a) < value(b);
}

struct min_max_temperature {
    void operator()(const pair<int, short>& t) {
        if(t.second == INVALID)
            return;
        if(min == INVALID || min > t.second))
            min = t.second;
        if(max == INVALID || max < t.second))
            max = t.second;
    }
    short min = INVALID;
    short max = INVALID;
};
auto min_max = std::foreach(temperatures.begin(), temperatures.end(), min_max_temperature());

using yes_type = char;
struct no_type { char padding[8]; };

template<typename T>
struct is_nullable_enum {
    template<typename U, U u = U::null> static yes_type test(U*);
    template<typename U> static no_type test(...);
    const static bool value = std::is_enum<T>::value && sizeof(test<T>(nullptr)) == sizeof(yes_type);
};

template<class T>
typename std::enable_if<is_nullable_enum<T>::value, std::ostream&>::type
operator<<(std::ostream& os, T value) {
    if(value == T::null) os << "null";
    else os << static_cast<std::underlying_type<T>::type>(value);
    return os;
}

enum class temperature_t : short { null = 0x7fff };

int main() {
    temperature_t t = temperature_t::null;
    std::cout << t << std::endl; // --> null
    t = temperature_t(0);
    std::cout << t << std::endl; // --> 0

    return 0;
}