struct stri_less
    : public std::binary_function<std::string, std::string, bool>
{
    bool operator()(const std::string &a, const std::string &b)
    { return _stricmp(a.c_str(), b.c_str()) < 0; }
};

std::multiset<std::string, stri_less> mset;
mset.insert("case");
mset.insert("Case");
mset.insert("caesar");
mset.insert("cASe");
mset.insert("CasE");
mset.insert("casual");

mset.equal_range("case"); // интервал со всеми видами "case"

enum Fruit{Apple, Pear, Kiwi};
struct Masha_t {
  std::multiset<Fruit> basket;
}Masha;

for(int i=0; i<4; ++i)
  Masha.basket.insert(Apple);

for(int i=0; i<3; ++i)
  Masha.basket.insert(Pear);

size_t answer = Masha.basket.size();

struct T { int a, b, c, d, e };

strunct T_compare
  : public std::binary_function<T*, T*, bool>
{
  T_compare(void) : f_(boost::bind(T::d, _1) < boost::bind(T::d, _2)) {}
  bool operator()(T* lhs, T*, rhs) { return f_(lhs, rhs); }
private:
  boost::function<bool (T*, T*)> f_;
}

multisetset<T*, T_compare>

multiset: The key value of an element in a multiset may not be changed directly.
multimap: The value of an element in a multimap, but not its associated key value, may be changed directly.

#include <stdio.h>
#include <set>

struct s;
struct x_cmp { bool operator()(const s* s1, const s* s2) const; };
struct y_cmp { bool operator()(const s* s1, const s* s2) const; };

typedef std::multiset<s*, x_cmp> x_idx_type;
typedef std::multiset<s*, y_cmp> y_idx_type;
typedef x_idx_type::iterator x_iterator;
typedef y_idx_type::iterator y_iterator;

struct s
{
    s(int x, int y) : x(x), y(y) {}
    int x;
    int y;
    x_iterator x_it;
    y_iterator y_it;
};
bool x_cmp::operator()(const s* s1, const s* s2) const { return s1->x<s2->x; } 
bool y_cmp::operator()(const s* s1, const s* s2) const { return s1->y<s2->y; }

int main()
{
    x_idx_type    x_idx;
    y_idx_type    y_idx;
    for(int x=0;x<4;++x)
    {
        for(int y=0;y<4;++y)
        {
            s* ps = new s(x,y);
            ps->x_it = x_idx.insert(ps);
            ps->y_it = y_idx.insert(ps);
        }
    }
    for(x_iterator it=x_idx.begin();it!=x_idx.end();++it) printf("%d,%d;", (*it)->x, (*it)->y); printf("\n");
    // удалить все, для которых y = 2
    s key(0,2);
    std::pair<y_iterator, y_iterator> y_range = y_idx.equal_range(&key);
    y_iterator y_it = y_range.first;
    while(y_it!=y_range.second)
    {
        s* ps = *y_it;
        x_idx.erase(ps->x_it);
        y_idx.erase(y_it++);
        delete ps;
    }
    for(x_iterator it=x_idx.begin();it!=x_idx.end();++it) printf("%d,%d;", (*it)->x, (*it)->y); printf("\n");
    return 0;
}

//Все очень просто 
//multiset может хотябы пригодится для случаев когда он хранит класс 
//для которого перегружен оператор меньше таким образом что сравнивается одно поле
//а второе поле игнорируется но при этом вторые поля у сравниваемых объектов могут отличаться
//здесь собсвтенно мультисет и может пригодится 
//как пример 
#include <iostream>
#include <string>
#include <set>
#include <iterator>
struct asc{ 
 int key;
 std::string value;
 asc( int k, std::string v ) : key(k),value(v) { } 
 asc( ) {} 
 bool operator < ( const asc &object ) const { 
  return key < object.key;
 } 
};

int main() { 
 std::set< asc > so;
 std::multiset< asc > sm;
 
 so.insert( asc( 1, "before" ) );
 so.insert( asc( 1, "after" ) );

 sm.insert( asc( 1, "before" ) );
 sm.insert( asc( 1, "after" ) );
 
 std::cout << "so size = " << so.size() << std::endl; //здесь мы потеряем значение
 std::cout << "sm size = " << sm.size() << std::endl; //здесь все в порядке
}

А>//Все очень просто 
А>//multiset может хотябы пригодится для случаев когда он хранит класс 
А>//для которого перегружен оператор меньше таким образом что сравнивается одно поле
А>//а второе поле игнорируется но при этом вторые поля у сравниваемых объектов могут отличаться
А>//здесь собсвтенно мультисет и может пригодится 
А>

Стандартном не предусмотрено изменение value здесь, в отличии от multimap.
Не предусмотрен поиск по отдельно key.