#include <algorithm>
#include <cctype>
#include <cassert>
#include <set>
#include <string>

struct icase_less {
  bool operator()(const std::string& x, const std::string& y) const {
    // для однобайтных кодировок без учёта диграфов типа эсцета - сойдёт
    return std::lexicographical_compare(
      std::begin(x), std::end(x),
      std::begin(y), std::end(y),
      [](char a, char b)->bool { return std::toupper(a) < std::toupper(b); } );
  }
};

template<class LESS>
struct dependent_equal {
 LESS less;
 template<class X, class Y>
 bool operator()(X&& x, Y&& y) const {
   return !less(std::forward<X>(x), std::forward<Y>(y))
       && !less(std::forward<Y>(y), std::forward<X>(x));
 }
};

int main() {
  using icase_multiset = std::multiset<std::string, icase_less>;
  icase_multiset xx = { "alfa", "beta", "Beta", "BETA", "gamma" };
  icase_multiset yy = { "alfa", "Beta", "BETA", "BeTa", "gamma" };
  //                            <--------------------> класс эквивалентности "beta"

  using icase_equal = dependent_equal<icase_less>;
  // выполняем попарное сравнение
  assert( std::equal(std::begin(xx), std::end(xx),
                     std::begin(yy), std::end(yy),
                     icase_equal()));
  // попарное сравнение без "без учёта регистра" не прокатит
  assert(!std::equal(std::begin(xx), std::end(xx),
                     std::begin(yy), std::end(yy)));
}

std::multimap<uint_t, string_t> m;
m.emplace(0, string_t("dfdf"));
m.emplace(0, string_t("nnnf"));

23.2.5 Unordered associative containers [unord.req]
...
6 An unordered associative container supports unique keys if it may contain at most one element for each
key. Otherwise, it supports equivalent keys. unordered_set and unordered_map support unique keys.
unordered_multiset and unordered_multimap support equivalent keys. In containers that support equivalent
keys, elements with equivalent keys are adjacent to each other in the iteration order of the container.
Thus, although the absolute order of elements in an unordered container is not specified, its elements are
grouped into equivalent-key groups such that all elements of each group have equivalent keys. Mutating
operations on unordered containers shall preserve the relative order of elements within each equivalent-key
group unless otherwise specified.
...
9 The elements of an unordered associative container are organized into buckets. Keys with the same hash
code appear in the same bucket. The number of buckets is automatically increased as elements are added
to an unordered associative container, so that the average number of elements per bucket is kept below
a bound. Rehashing invalidates iterators, changes ordering between elements, and changes which buckets
elements appear in, but does not invalidate pointers or references to elements. For unordered_multiset and
unordered_multimap, rehashing preserves the relative ordering of equivalent elements.

V>std::multimap<uint_t, string_t> m;
V>m.emplace(0, string_t("dfdf"));
V>m.emplace(0, string_t("nnnf"));
V>

struct comparator {
  bool operator()(int x, int y) const { return abs(x) < abs(y); }
};

std::multimap<int, std::string, comparator> m;
m.emplace( 1, "hello");
m.emplace( 1, "world");
m.emplace(-1, "antimatter");
m.emplace( 1, "matter");

23.2.4 Associative containers [associative.reqmts]
...
Table 86 — Associative container requirements (in addition to container)
...
a_eq.emplace(args)
Effects: Inserts a value_type
object t constructed with
std::forward<Args>(args)...
and returns the iterator
pointing to the newly inserted
element. If a range containing
elements equivalent to t exists
in a_eq, t is inserted at the
end of that range.