c++11 标准模板(STL)(std::multimap)(九)

定义于头文件 <map>
template<

    class Key,
    class T,
    class Compare = std::less<Key>,
    class Allocator = std::allocator<std::pair<const Key, T> >

> class multimap;
(1)
namespace pmr {

    template <class Key, class T, class Compare = std::less<Key>>
    using multimap = std::multimap<Key, T, Compare,
                                  std::pmr::polymorphic_allocator<std::pair<const Key,T>>>;

}
(2)(C++17 起)

 multimap 是关联容器,含有关键-值 pair 的已排序列表,同时容许多个入口拥有同一关键。按照应用到关键的比较函数 Compare 排序。搜索、插入和移除操作拥有对数复杂度。

拥有等价关键的关键-值 pair 的顺序就是插入顺序,且不会更改。(C++11 起)

凡在标准库使用比较 (Compare) 概念出,都用描述于比较 (Compare) 上的等价关系确定等价性。不精确地说,若二个对象 ab 互不小于对方: !comp(a, b) && !comp(b, a) ,则认为它们等价。

观察器

返回用于比较键的函数

std::multimap<Key,T,Compare,Allocator>::key_comp

key_compare key_comp() const;

返回用于比较关键的函数对象,它是此容器构造函数参数 comp 的副本。

参数

(无)

返回值

比较关键的函数对象。

复杂度

常数

返回用于在value_type类型的对象中比较键的函数

std::multimap<Key,T,Compare,Allocator>::value_comp

std::multimap::value_compare value_comp() const;

 返回比较 std::multimap::value_type (关键-值 pair )对象的函数对象,它用 key_comp 比较 pair 的第一组分。

参数

(无)

返回值

比较值的函数对象。

复杂度

常数。

非成员函数

按照字典顺序比较 multimap 中的值

operator==,!=,<,<=,>,>=(std::multimap)
template< class Key, class T, class Compare, class Alloc >

bool operator==( const std::multimap<Key,T,Compare,Alloc>& lhs,

                 const std::multimap<Key,T,Compare,Alloc>& rhs );
(1)
template< class Key, class T, class Compare, class Alloc >

bool operator!=( const std::multimap<Key,T,Compare,Alloc>& lhs,

                 const std::multimap<Key,T,Compare,Alloc>& rhs );
(2)
template< class Key, class T, class Compare, class Alloc >

bool operator<( const std::multimap<Key,T,Compare,Alloc>& lhs,

                const std::multimap<Key,T,Compare,Alloc>& rhs );
(3)
template< class Key, class T, class Compare, class Alloc >

bool operator<=( const std::multimap<Key,T,Compare,Alloc>& lhs,

                 const std::multimap<Key,T,Compare,Alloc>& rhs );
(4)
template< class Key, class T, class Compare, class Alloc >

bool operator>( const std::multimap<Key,T,Compare,Alloc>& lhs,

                const std::multimap<Key,T,Compare,Alloc>& rhs );
(5)
template< class Key, class T, class Compare, class Alloc >

bool operator>=( const std::multimap<Key,T,Compare,Alloc>& lhs,

                 const std::multimap<Key,T,Compare,Alloc>& rhs );
(6)

 比较二个容器的内容。

1-2) 检查 lhsrhs 的内容是否相等,即它们是否拥有相同数量的元素且 lhs 中每个元素与 rhs 的同位置元素比较相等。

3-6) 按字典序比较 lhsrhs 的内容。由等价于 std::lexicographical_compare 的函数进行比较。此比较忽略容器的定序 Compare 。

参数

lhs, rhs-要比较内容的容器
- 为使用重载 (1-2) , T, Key 必须满足可相等比较 (EqualityComparable) 的要求。
- 为使用重载 (3-6) , Key 必须满足可小于比较 (LessThanComparable) 的要求。顺序关系必须建立全序。

返回值

1) 若容器内容相等则为 true ,否则为 false

2) 若容器内容不相等则为 true ,否则为 false

3) 若 lhs 的内容按字典序小于 rhs 的内容则为 true ,否则为 false

4) 若 lhs 的内容按字典序小于等于 rhs 的内容则为 true ,否则为 false

5) 若 lhs 的内容按字典序大于 rhs 的内容则为 true ,否则为 false

6) 若 lhs 的内容按字典序大于等于 rhs 的内容则为 true ,否则为 false

复杂度

1-2) 若 lhsrhs 的大小不同则为常数,否则与容器大小成线性

3-6) 与容器大小成线性

特化 std::swap 算法

std::swap(std::multimap)
template< class Key, class T, class Compare, class Alloc >

void swap( multimap<Key,T,Compare,Alloc>& lhs,

           multimap<Key,T,Compare,Alloc>& rhs );
(C++17 前)
template< class Key, class T, class Compare, class Alloc >

void swap( multimap<Key,T,Compare,Alloc>& lhs,

           multimap<Key,T,Compare,Alloc>& rhs ) noexcept(/* see below */);
(C++17 起)

 为 std::multimap 特化 std::swap 算法。交换 lhsrhs 的内容。调用 lhs.swap(rhs) 。

参数

lhs, rhs-要交换内容的容器

返回值

(无)

复杂度

常数。

调用示例

#include <iostream>
#include <forward_list>
#include <string>
#include <iterator>
#include <algorithm>
#include <functional>
#include <map>
#include <time.h>

using namespace std;

struct Cell
{
    int x;
    int y;

    Cell() = default;
    Cell(int a, int b): x(a), y(b) {}

    Cell &operator +=(const Cell &cell)
    {
        x += cell.x;
        y += cell.y;
        return *this;
    }

    Cell &operator +(const Cell &cell)
    {
        x += cell.x;
        y += cell.y;
        return *this;
    }

    Cell &operator *(const Cell &cell)
    {
        x *= cell.x;
        y *= cell.y;
        return *this;
    }

    Cell &operator ++()
    {
        x += 1;
        y += 1;
        return *this;
    }


    bool operator <(const Cell &cell) const
    {
        if (x == cell.x)
        {
            return y < cell.y;
        }
        else
        {
            return x < cell.x;
        }
    }

    bool operator >(const Cell &cell) const
    {
        if (x == cell.x)
        {
            return y > cell.y;
        }
        else
        {
            return x > cell.x;
        }
    }

    bool operator ==(const Cell &cell) const
    {
        return x == cell.x && y == cell.y;
    }
};

struct myCompare
{
    bool operator()(const int &a, const int &b)
    {
        return a < b;
    }
};

std::ostream &operator<<(std::ostream &os, const Cell &cell)
{
    os << "{" << cell.x << "," << cell.y << "}";
    return os;
}

std::ostream &operator<<(std::ostream &os, const std::pair<const int, Cell> &pCell)
{
    os << pCell.first << "-" << pCell.second;
    return os;
}

int main()
{
    std::cout << std::boolalpha;

    std::mt19937 g{std::random_device{}()};
    srand((unsigned)time(NULL));

    auto genKey = []()
    {
        return std::rand() % 10 + 100;
    };

    auto generate = []()
    {
        int n = std::rand() % 10 + 100;
        Cell cell{n, n};
        return cell;
    };

    std::multimap<int, Cell> multimap1;
    for (size_t index = 0; index < 5; index++)
    {
        //插入以给定的 args 原位构造的新元素到容器。
        multimap1.emplace(genKey(), generate());
    }
    std::cout << "multimap1:    ";
    std::copy(multimap1.begin(), multimap1.end(), std::ostream_iterator<std::pair<const int, Cell>>(std::cout, " "));
    std::cout << std::endl;

    std::multimap<int, Cell> multimap2;
    for (size_t index = 0; index < 5; index++)
    {
        //插入以给定的 args 原位构造的新元素到容器。
        multimap2.emplace(genKey(), generate());
    }
    std::cout << "multimap2:    ";
    std::copy(multimap2.begin(), multimap2.end(), std::ostream_iterator<std::pair<const int, Cell>>(std::cout, " "));
    std::cout << std::endl;
    std::cout << std::endl;

    //比较二个容器的内容。
    //1) 若容器内容相等则为 true ,否则为 false
    std::cout << "multimap1 == multimap1 :  " << (multimap1 == multimap2) << std::endl;
    //2) 若容器内容不相等则为 true ,否则为 false
    std::cout << "multimap1 != multimap1 :  " << (multimap1 != multimap2) << std::endl;
    //3) 若 lhs 的内容按字典序小于 rhs 的内容则为 true ,否则为 false
    std::cout << "multimap1 <  multimap1 :  " << (multimap1 <  multimap2) << std::endl;
    //4) 若 lhs 的内容按字典序小于或等于 rhs 的内容则为 true ,否则为 false
    std::cout << "multimap1 <= multimap1 :  " << (multimap1 <= multimap2) << std::endl;
    //5) 若 lhs 的内容按字典序大于 rhs 的内容则为 true ,否则为 false
    std::cout << "multimap1 >  multimap1 :  " << (multimap1 >  multimap2) << std::endl;
    //6) 若 lhs 的内容按字典序大于或等于 rhs 的内容则为 true ,否则为 false
    std::cout << "multimap1 >= multimap1 :  " << (multimap1 >= multimap2) << std::endl;
    std::cout << std::endl;


    //返回用于比较关键的函数对象,它是此容器构造函数参数 comp 的副本。
    auto key_comp = multimap2.key_comp();
    std::cout << "key_comp(multimap1.begin()->first, multimap2.begin()->first) :    "
              << key_comp(multimap1.begin()->first, multimap2.begin()->first) << std::endl;
    std::cout << std::endl;

    auto value_comp = multimap2.value_comp();
    std::cout << "value_comp(*multimap1.begin(), *multimap2.begin()) :              "
              << value_comp(*multimap1.begin(), *multimap2.begin()) << std::endl;
    std::cout << std::endl;

    //为 std::multimap 特化 std::swap 算法。交换 lhs 与 rhs 的内容。调用 lhs.swap(rhs) 。
    std::swap(multimap1, multimap2);

    std::cout << "multimap1:    ";
    std::copy(multimap1.begin(), multimap1.end(), std::ostream_iterator<std::pair<const int, Cell>>(std::cout, " "));
    std::cout << std::endl;

    std::cout << "multimap2:    ";
    std::copy(multimap2.begin(), multimap2.end(), std::ostream_iterator<std::pair<const int, Cell>>(std::cout, " "));
    std::cout << std::endl;
    std::cout << std::endl;

    return 0;
}

输出

 

  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值