Yes, an "object compares less than 0" means that object < 0 will yield true . Likewise, compares equal to 0 means object == 0 will yield true, and compares greater than 0 means object > 0 will yield true.

As to why he doesn't use the phrase "is less than 0", I'd guess it's to emphasize that this is all that's guaranteed. For example, this could be essentially any arbitrary type, including one that doesn't really represent an actual value, but instead only supports comparison with 0.

Just, for example, let's consider a type something like this:

class comparison_result { enum { LT, GT, EQ } res; friend template <class Integer> bool operator<(comparison_result c, Integer) { return c.res == LT; } friend template <class Integer> bool operator<(Integer, comparison_result c) { return c.res == GT; } // and similarly for `>` and `==` };

[For the moment, let's assume the friend template<...> stuff is all legit--I think you get the basic idea, anyway).

This doesn't really represent a value at all. It just represents the result of "if compared to 0, should the result be less than, equal to, or greater than". As such, it's not that it is less than 0, only that it produces true or false when compared to 0 (but produces the same results when compared to another value).

As to whether <0 being true means that >0 and ==0 must be false (and vice versa): there is no such restriction on the return type for the operator itself. The language doesn't even include a way to specify or enforce such a requirement. There's nothing in the spec to prevent them from all returning true . Returning true for all the comparisons is possible and seems to be allowed, but it's probably pretty far-fetched.