We often want to compare class instances to each other. For example, two date class instances. However, we have to tediously write out the implementations for operator>, operator<, operator==, operator>=, etc. which all have the same exact comparison logic, but simply a different return value. This is tedious and distracts the programmer.

Instead, there should be a mechanism to write a single private comparison member function that behaves like the comparator in qsort, returning 1, 0 or -1. Then the compiler would automatically generate all the relational operator overloads. Here's an example:

class date {
    int yr, mo, day;
    /* new keyword: generate. Signals to the compiler that this method will
       provide the logic of the comparisons. */
    friend generate int cmp(const date &lhs, const date &rhs);
public:
    /* constructors, etc. as usual */
};


This would require the use of a new keyword, which I've called generate (maybe a better name can be found that would minimize collision). This keyword is used so the compiler knows that it needs to auto-generate the relational operators for a class, and which function to call for implementing the comparison logic itself.

The operators that the compiler will auto generate will look like this:

friend bool operator==(const date &lhs, const date &rhs)
{
    return cmp(lhs, rhs) == 0;
}

and so on and so forth for each relational operator.

If, for some reason, a programmer wants to generate all relational operators except certain ones, then they can use the =delete notation. So for the date class above, let's say we want to auto-generate all relational operators except operator!=. Then the class would look like this:

  class date {
    int yr, mo, day;
    /* new keyword: generate. Signals to the compiler that this method will
       provide the logic of the comparisons. */
    friend generate int cmp(const date &lhs, const date &rhs);
public:
    /* constructors, etc. as usual */
    friend bool operator!=(const date &lhs, const date &rhs) = delete;
}


The only objections I can anticipate to this proposal is that this feature would (1) significantly increase compilation times, as the compiler must generate new code; and (2) that a new keyword would be added, which may cause name clashes.

However, the existence of templates, which auto-generates far more code than this would, refutes point (1). And point (2) can also be mitigated because the Standard can alternatively require a certain name for the comparison method, such as cmp, similar to how main is required to be the program entry point. This would eliminate the need to invent a new keyword.