# Creating std map with user-defined types as key

suggest changeIn order to be able to use a class as the key in a map, all that is required of the key is that it be `copiable`

and `assignable`

. The ordering within the map is defined by the third argument to the template (and the argument to the constructor, if used). This *defaults* to `std::less<KeyType>`

, which defaults to the `\<`

operator, but there’s no requirement to use the defaults. Just write a comparison operator (preferably as a functional object):

```
struct CmpMyType
{
bool operator()( MyType const& lhs, MyType const& rhs ) const
{
// ...
}
};
```

In C++, the “compare” predicate must be a strict weak ordering. In particular, `compare(X,X)`

must return `false`

for any `X`

. i.e. if `CmpMyType()(a, b)`

returns true, then `CmpMyType()(b, a)`

must return false, and if both return false, the elements are considered equal (members of the same equivalence class).

# Strict Weak Ordering

This is a mathematical term to define a relationship between two objects.

Its definition is:

Two objects x and y are equivalent if both f(x, y) and f(y, x) are false. Note that an object is always (by the irreflexivity invariant) equivalent to itself.

In terms of C++ this means if you have two objects of a given type, you should return the following values when compared with the operator <.

```
X a;
X b;
Condition: Test: Result
a is equivalent to b: a < b false
a is equivalent to b b < a false
a is less than b a < b true
a is less than b b < a false
b is less than a a < b false
b is less than a b < a true
```

How you define equivalent/less is totally dependent on the type of your object.