c++11 标准模板（STL）（std::unordered_multimap）（二）

编程语言 2023-04-06 20:43:47 阅读次数: 0 
定义于头文件 <unordered_map>
template<

    class Key,
    class T,
    class Hash = std::hash<Key>,
    class KeyEqual = std::equal_to<Key>,
    class Allocator = std::allocator< std::pair<const Key, T> >

> class unordered_multimap;		 (1) (C++11 起)
namespace pmr {

    template <class Key, class T,
              class Hash = std::hash<Key>,
              class Pred = std::equal_to<Key>>
    using unordered_multimap = std::unordered_multimap<Key, T, Hash, Pred,
                                   std::pmr::polymorphic_allocator<std::pair<const Key,T>>>;

}		 (2) (C++17 起)

 unordered_multimap 是无序关联容器，支持等价的关键（一个 unordered_multimap 可含有每个关键值的多个副本）和将关键与另一类型的值关联。 unordered_multimap 类支持向前迭代器。搜索、插入和移除拥有平均常数时间复杂度。

元素在内部不以任何特定顺序排序，而是组织到桶中。元素被放进哪个桶完全依赖于其关键的哈希。这允许到单独元素的快速访问，因为哈希一旦计算，则它指代元素被放进的准确的桶。

不要求此容器的迭代顺序稳定（故例如 std::equal 不能用于比较二个 std::unordered_multimap ），除了关键比较等价（以 key_eq() 为比较器比较相等）的每组元素在迭代顺序中组成相接的子范围，它亦可用 equal_range() 访问。

成员函数

构造 unordered_multimap

std::unordered_multimap<Key,T,Hash,KeyEqual,Allocator>::unordered_multimap
unordered_multimap() : unordered_multimap( size_type(/*implementation-defined*/) ) {}

explicit unordered_multimap( size_type bucket_count,
                             const Hash& hash = Hash(),
                             const key_equal& equal = key_equal(),

                             const Allocator& alloc = Allocator() );		 (1) (C++11 起)
unordered_multimap( size_type bucket_count,

                    const Allocator& alloc )
                   : unordered_multimap(bucket_count, Hash(), key_equal(), alloc) {}
unordered_multimap( size_type bucket_count,
                    const Hash& hash,
                    const Allocator& alloc )

                   : unordered_multimap(bucket_count, hash, key_equal(), alloc) {}		 (1) (C++14 起)

explicit unordered_multimap( const Allocator& alloc );

 (1) (C++11 起)
template< class InputIt >

unordered_multimap( InputIt first, InputIt last,
                    size_type bucket_count = /*implementation-defined*/,
                    const Hash& hash = Hash(),
                    const key_equal& equal = key_equal(),

                    const Allocator& alloc = Allocator() );		 (2) (C++11 起)
template< class InputIt >

unordered_multimap( InputIt first, InputIt last,
                    size_type bucket_count,
                    const Allocator& alloc )
                   : unordered_multimap(first, last,

                       bucket_count, Hash(), key_equal(), alloc) {}		 (2) (C++14 起)
template< class InputIt >

unordered_multimap( InputIt first, InputIt last,
                    size_type bucket_count,
                    const Hash& hash,
                    const Allocator& alloc )
                   : unordered_multimap(first, last,

                       bucket_count, hash, key_equal(), alloc) {}		 (2) (C++14 起)

unordered_multimap( const unordered_multimap& other );

 (3) (C++11 起)

unordered_multimap( const unordered_multimap& other, const Allocator& alloc );

 (3) (C++11 起)

unordered_multimap( unordered_multimap&& other );

 (4) (C++11 起)

unordered_multimap( unordered_multimap&& other, const Allocator& alloc );

 (4) (C++11 起)
unordered_multimap( std::initializer_list<value_type> init,

                    size_type bucket_count = /*implementation-defined*/,
                    const Hash& hash = Hash(),
                    const key_equal& equal = key_equal(),

                    const Allocator& alloc = Allocator() );		 (5) (C++11 起)
unordered_multimap( std::initializer_list<value_type> init,

                    size_type bucket_count,
                    const Allocator& alloc )
                   : unordered_multimap(init, bucket_count,

                       Hash(), key_equal(), alloc) {}		 (5) (C++14 起)
unordered_multimap( std::initializer_list<value_type> init,

                    size_type bucket_count,
                    const Hash& hash,
                    const Allocator& alloc )
                   : unordered_multimap(init, bucket_count,

                       hash, key_equal(), alloc) {}		 (5) (C++14 起)

从各种数据源构造新容器。可选的以用户提供的 bucket_count 为用于创建的最小桶数，以 hash 为哈希函数，以 equal 为比较关键的函数，和以 alloc 为分配器。

1) 构造空容器。设置 max_load_factor() 为 1.0 。对于默认构造函数，桶数是实现定义的。

2) 构造拥有范围 [first, last) 的内容的容器。设置 max_load_factor() 为 1.0 。

3) 复制构造函数。构造拥有 other 内容副本的容器，一同复制加载因子、谓词和哈希函数。若不提供 alloc ，则通过调用 std::allocator_traits<allocator_type>::select_on_container_copy_construction(other.get_allocator()) 获得分配器。

4) 移动构造函数。用移动语义构造拥有 other 内容的容器。若不提供 alloc ，则通过从属于 other 的分配器移动构造获得分配器。

5) 构造拥有 initializer_list init 内容的容器，同 unordered_multimap(init.begin(), init.end()) 。

参数

alloc - 用于此容器所有内存分配器的分配器
bucket_count - 初始化时用的最小桶数。若不指定，则使用实现定义的默认值
hash - 要用的哈希函数
equal - 用于此容器所有关键比较的比较函数
first, last - 复制元素来源的范围
other - 用作源以初始化容器元素的另一容器
init - 用以初始化容器元素的 initializer_list
类型要求
- InputIt 必须满足遗留输入迭代器 (LegacyInputIterator) 的要求。

复杂度

1) 常数

2) 平均情况与 first 和 last 间的距离成线性，最坏情况成平方。

3) 与 other 的大小成线性。

4) 常数。若给定 alloc 且 alloc != other.get_allocator() 则为线性。

5) 平均情况与 init 的大小成线性，最坏情况成平方。

异常

对 Allocator::allocate 的调用可能抛出。

注意

在容器移动构造（重载 (4) ）后，指向 other 的引用及迭代器（除了尾迭代器）保持合法，但指代现于 *this 中的元素。当前标准由 [container.requirements.general]/12 中的总括陈述作出此保证，而 LWG 2321 正在考虑更严格的保证。

析构 unordered_multimap

std::unordered_multimap<Key,T,Hash,KeyEqual,Allocator>::~unordered_multimap

~unordered_multimap();

 (C++11 起)

销毁容器。调用元素的析构函数，然后解分配所用的存储。注意，若元素是指针，则不销毁所指向的对象。

复杂度

与容器大小成线性。

调用示例

#include <iostream>
#include <forward_list>
#include <string>
#include <iterator>
#include <algorithm>
#include <functional>
#include <unordered_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<Cell, string> &pCell)
{
    os << pCell.first << "-" << pCell.second;
    return os;
}

struct CHash
{
    size_t operator()(const Cell& cell) const
    {
        size_t thash = std::hash<int>()(cell.x) | std::hash<int>()(cell.y);
//        std::cout << "CHash: " << thash << std::endl;
        return thash;
    }
};

struct CEqual
{
    bool operator()(const Cell &a, const Cell &b) const
    {
        return a.x == b.x && a.y == b.y;
    }
};

int main()
{
    auto generate = []()
    {
        int n = std::rand() % 10 + 110;
        Cell cell{n, n};
        return std::pair<Cell, string>(cell, std::to_string(n));
    };

    //1) 构造空容器。设置 max_load_factor() 为 1.0 。对于默认构造函数，桶数是实现定义的。
    std::unordered_multimap<Cell, string, CHash, CEqual> unordered_multimap1;
    std::cout << "unordered_multimap1 is empty " << unordered_multimap1.empty()
              << "  bucket_count:   " << unordered_multimap1.bucket_count() << std::endl;

    std::unordered_multimap<Cell, string, CHash, CEqual> unordered_multimap6(6);
    std::cout << "unordered_multimap6 is empty " << unordered_multimap6.empty()
              << "  bucket_count:   " << unordered_multimap6.bucket_count() << std::endl;
    std::cout << std::endl;

    std::vector<std::pair<Cell, string>> vector1(6);
    std::generate(vector1.begin(), vector1.end(), generate);
    std::cout << "vector1:                  ";
    std::copy(vector1.begin(), vector1.end(), std::ostream_iterator<std::pair<Cell, string>>(std::cout, " "));
    std::cout << std::endl;


    //2) 构造拥有范围 [first, last) 的内容的容器。
    //设置 max_load_factor() 为 1.0 。若范围中的多个元素拥有比较等价的关键，则插入哪个元素是未指定的。
    std::unordered_multimap<Cell, string, CHash, CEqual> unordered_multimap2(vector1.begin(), vector1.end());
    std::cout << "unordered_multimap2 size:  " << unordered_multimap2.size()
              << "  bucket_count:   " << unordered_multimap2.bucket_count() << std::endl;
    std::cout << "unordered_multimap2:   ";
    std::copy(unordered_multimap2.begin(), unordered_multimap2.end(), std::ostream_iterator<std::pair<Cell, string>>(std::cout, " "));
    std::cout << std::endl;

    std::unordered_multimap<Cell, string, CHash, CEqual> unordered_multimap7(vector1.begin(), vector1.end(), 8);
    std::cout << "unordered_multimap7 size:  " << unordered_multimap7.size()
              << "  bucket_count:   " << unordered_multimap7.bucket_count() << std::endl;
    std::cout << "unordered_multimap7:   ";
    std::copy(unordered_multimap7.begin(), unordered_multimap7.end(), std::ostream_iterator<std::pair<Cell, string>>(std::cout, " "));
    std::cout << std::endl;
    std::cout << std::endl;


    //3) 复制构造函数。构造拥有 other 内容副本的容器，一同复制加载因子、谓词和哈希函数。
    std::unordered_multimap<Cell, string, CHash, CEqual> unordered_multimap3(unordered_multimap2);
    std::cout << "unordered_multimap3 size:  " << unordered_multimap3.size()
              << "  bucket_count:   " << unordered_multimap3.bucket_count() << std::endl;
    std::cout << "unordered_multimap3:   ";
    std::copy(unordered_multimap3.begin(), unordered_multimap3.end(), std::ostream_iterator<std::pair<Cell, string>>(std::cout, " "));
    std::cout << std::endl;
    std::cout << std::endl;


    //4) 移动构造函数。用移动语义构造拥有 other 内容的容器。
    //若不提供 alloc ，则通过从属于 other 的分配器移动构造获得分配器。
    std::unordered_multimap<Cell, string, CHash, CEqual> unordered_multimap4(std::move(unordered_multimap2));
    std::cout << "unordered_multimap4:   ";
    std::copy(unordered_multimap4.begin(), unordered_multimap4.end(), std::ostream_iterator<std::pair<Cell, string>>(std::cout, " "));
    std::cout << std::endl;
    std::cout << std::endl;


    //5) 构造拥有 initializer_list init 内容的容器，同 unordered_multimap(init.begin(), init.end()) 。
    std::unordered_multimap<Cell, string, CHash, CEqual> unordered_multimap5
    {generate(), generate(), generate(), generate(), generate(), generate()};
    std::cout << "unordered_multimap5 size:  " << unordered_multimap5.size()
              << "  bucket_count:   " << unordered_multimap5.bucket_count() << std::endl;
    std::cout << "unordered_multimap5:   ";
    std::copy(unordered_multimap5.begin(), unordered_multimap5.end(), std::ostream_iterator<std::pair<Cell, string>>(std::cout, " "));
    std::cout << std::endl;

    std::unordered_multimap<Cell, string, CHash, CEqual> unordered_multimap8
    ({generate(), generate(), generate(), generate(), generate(), generate()}, 8);
    std::cout << "unordered_multimap8 size:  " << unordered_multimap8.size()
              << "  bucket_count:   " << unordered_multimap8.bucket_count() << std::endl;
    std::cout << "unordered_multimap8:   ";
    std::copy(unordered_multimap8.begin(), unordered_multimap8.end(), std::ostream_iterator<std::pair<Cell, string>>(std::cout, " "));
    std::cout << std::endl;
    return 0;
}

猜你喜欢

转载自blog.csdn.net/qq_40788199/article/details/129772786
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
Java自定义时间格式
同步整形电路
在开发中最最最常用的字符串的属性大集合
Linux 查看端口占用并杀掉
Java基础四：ArrayList
多线程之死锁就是这么简单
mysql 基础命令集
awk 命令详解
Centos6.3编译安装nginx+php步骤
OCR （Optical Character Recognition，光学字符识别）
每日归档
更多
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022