map<size_t, vector*>

#include <map>
#include <string>
#include <vector>

//typedef std::pair<std::string, std::vector<int> > Pair;
typedef std::map<int, std::pair<std::string, std::vector<int> > >str2vec;

int main()
{
  str2vec m;
  std::vector<int> v;
  v.push_back(1);
  m.insert(std::make_pair(v.size(), std::make_pair("abc", v)));
  return 0;
}

sc>>#include <map>
sc>>#include <string>
sc>>#include <vector>

sc>>//typedef std::pair<std::string, std::vector<int> > Pair;
sc>>typedef std::map<int, std::pair<std::string, std::vector<int> > >str2vec;

sc>>int main()
sc>>{
sc>>  str2vec m;
sc>>  std::vector<int> v;
sc>>  v.push_back(1);
sc>>  m.insert(std::make_pair(v.size(), std::make_pair("abc", v)));
sc>>  return 0;
sc>>}
sc>>

#include <map>
#include <vector>
#include <string>
#include <iostream>
#include <algorithm>

typedef std::vector<int> intvec;
typedef std::map<std::string, intvec> str2ivec;
typedef std::multimap<size_t, intvec*> size2ivec;
typedef std::pair<str2ivec::iterator, bool> it2bool;

void printmm(std::pair<size_t, intvec*> const& p)
{
    std::cout << p.first << "\t\t"; 
    std::copy(p.second->begin(), p.second->end(), std::ostream_iterator<int>(std::cout, " "));
    std::cout << std::endl;
}

it2bool insert(std::string const &p1, intvec const &p2, 
               str2ivec &m, size2ivec &mm)
{
    it2bool it = m.insert(std::make_pair(p1, p2));
    if(it.second)
    {        
        mm.insert(std::make_pair(p2.size(), &it.first->second));
    }
    return it;
}

int main(int argc, char* argv[])
{    
    intvec        v;
    v.push_back(10);
    str2ivec    m;
    size2ivec    mm;

    insert(std::string("abc"), v, m, mm);
    if(!insert(std::string("abc"), v, m, mm).second)
        std::cout << "abc key is already in map" << std::endl;
    v.push_back(20);
    insert(std::string("def"), v, m, mm);

    std::cout << "length\t\tvalues" << std::endl;
    std::for_each(mm.begin(), mm.end(), printmm);
    return 0;
}

template <
    class Key, 
    class Type, 
    class Compare = std::less<Key>, 
    class Allocator = std::allocator<std::pair<const Key, Type> > >
class mmap: public std::map<Key, Type, Compare, Allocator>
{
};

#include <iostream>
#include <string>
#include <sstream>
#include <map>
#include <algorithm>

// запись в логе
struct entry 
{
    std::string datetime;
    std::string page;
    std::string ip;
    std::string browser;

    friend std::istream& operator>>(std::istream &stream, entry &e)
    {
        entry t;
        if( !(stream >> t.datetime) )
            return stream;
        if( !(stream >> t.page) )
            return stream;
        if( !(stream >> t.ip) )
            return stream;
        if( !(stream >> t.browser) )
            return stream;
        e = t;
        return stream;
    }
}; // struct entry..

// менеджер сбора статистики
class statistic
{
private: // данные

    // статистика посещения страниц
    std::map<std::string, int> page_to_visit;
    // информация о количестве визитов
    std::multimap<int, std::string> visit_to_page;

public:
    // запросить статистику по количеству визитов посещенных страниц
    const std::multimap<int, std::string>& get_page_by_visit() const
    {
        return visit_to_page;
    }

    // обработать запись лога
    statistic& process(const entry &e) 
    {
        // прочитали количество визитов данной страницы 
        // до регистрации новой записи логе
        int visit_count = page_to_visit[e.page]++;

        if( visit_count ) {
            // запросили диапазон соответствующий полученному 
            // количеству визитов
            std::pair<
                std::multimap<int, std::string>::iterator,
                std::multimap<int, std::string>::iterator>
            range = visit_to_page.equal_range(visit_count);

            // ищем в нем нашу страницу
            for(std::multimap<int, std::string>::iterator i = range.first; i != range.second; i++) 
                // если страница найдена
                if( i->second == e.page ) 
                {
                    // удаляем старое упоминание поскольку число вхождений увеличилось
                    // и регистрируем запись с новым количеством 
                    visit_to_page.insert(
                        visit_to_page.erase(i), 
                        std::make_pair<int, std::string>(visit_count+1, e.page)
                    );
                    break;
                }
        } else {
            // регистрируем первый раз
            visit_to_page.insert(
                std::make_pair<int, std::string>(visit_count+1, e.page)
            );
        }
        return *this;
    } // add..
}; // class statistic..

// вспомогательный функтор, который выполняет роль посредника
// между алгоритмом for_each и менеждером статистики
struct process_entry
{
private:
    statistic *mng;
public:
    process_entry(statistic &mng) : mng(&mng) {}
    void operator()(const entry &e) 
    {
        mng->process(e);
    }
}; // struct process_entry..

// вспомогательный класс для вывода пары в поток
struct visit_count_page
{
    const std::pair<const int, std::string> *p;
    visit_count_page(const std::pair<const int, std::string> &r) : p(&r) {}

    friend std::ostream& operator<<(std::ostream &stream, const visit_count_page &p)
    {
        stream << p.p->first << " " << p.p->second;
        return stream;
    }
}; // struct visit_count_page..

int main()
{
    statistic mng;

    std::istringstream stream(
        "200709152019 index.html 127.0.0.1 IE7\n"
        "200709152025 index.html 127.0.0.1 IE7\n"
        "200709152125 index.html 127.0.0.1 IE7\n"
        "200709152225 overview.html 127.0.0.1 IE7\n"
        "200709152325 overview.html 127.0.0.1 IE7\n"
        "200709152327 about.html 127.0.0.1 IE7\n"
    );

    std::for_each(
        std::istream_iterator<entry>(stream),
        std::istream_iterator<entry>(),
        process_entry(mng)
    );

    const std::multimap<int, std::string> m = mng.get_page_by_visit();
    // вывод статистики по количеству посещений в порядке убывания интереса
    std::copy(
        m.rbegin(), 
        m.rend(), 
        std::ostream_iterator<visit_count_page>(std::cout, "\n")
    );
    return 0;
}

typedef std::pair<string, vector>  DataType;

struct MyComparer
{
    enum CompareBy { size, name, ip, browser_id, ... } compare_type;

    MyComparer(CompareBy  compare_type) : compare_type(compare_type) {}

    bool operator<(const DataType& a, const DataType& b) const
    {
        switch(compare_type)
        {
            case size: return a.second.size() < b.second.size();
            ...
        }
    }
};

typedef std::multiset< DataType, MyComparer >  MySet;


void rebuild_set(MySet& set, MyComparer::CompareBy cmp_type)
{
    //  строим новый set
    MySet new_set( MyComparer(cmp_type) );
    new_set.insert(set.begin(), set.end());
    std::swap(set, new_set);

    //  в случае set, map контейнеров этот ASSERT актуален
//  ASSERT(set.size() == new_set.size());
}