9.3 关联容器:QMap、QMultiMap

本节介绍两种基于红黑树的关联容器,单映射 QMap、多映射 QMultiMap。 前面介绍的顺序容器通常存储大量连续序号的元素,而关联容器则存储离散的“不正常序号”的元素。 数组和顺序容器的序号都是从 0 开始,逐渐递增,而关联容器没有正常的序号, 单映射和单哈希映射通过重载中括号[]运算符函数,它们的元素序号可以是各种奇葩的数值类型, 比如用字符串、图片、颜色、日期、字体等数据作为序号,像 map["红色"] = 0xFF0000 就是单映射的例子。 本节分为两个小节内容,依次介绍 QMap、QMultiMap ,并各安排一个示例使用这些关联容器。

9.3.1 单映射 QMap

QMap 模板类通常将数据按照 key - value(键-值) 配对的形式存储,程序中以 key 作为序号来查询对应的 value,比如  map["红色"] = 0xFF0000 。QMap 通常将一个 key 映射为一个 value,而 QMultiMap 通常将 一个 key 映射为多个 value,这就是单映射和多映射的区别。
QMap 模板类 key 和 value 的类型可以是C++和Qt常用的数据类型,也可以使用自定义类型,但是注意key 和 value 都必须是可赋值类型!
QMap 使用红黑树存储 key - value 配对数据( 一对 key - value 后文统称为映射中一个元素,或者红黑树的一个节点),排序时按照 key 来比较大小,因此对 key 类型有额外要求:
key 类型必须提供  operator<()  比较数值大小。

下面我们分类列举QMap模板类的功能函数:
(1)构造函数
    QMap()  //默认构造函数
    QMap(std::initializer_list<std::pair<Key, T> > list) //初始化列表构造函数
    QMap(const QMap<Key, T> & other) //复制构造函数
    QMap(QMap<Key, T> && other)   //移动构造函数
    QMap(const std::map<Key, T> & other) //根据标准库的映射构造 QMap
    ~QMap() //析构函数
最常用是默认构造函数,注意使用模板类时要带 key 和 value  的类型,例如定义姓名和年龄的映射:
QMap<QString, int> nameAge;
QString 作为 key 类型,保存姓名,int 作为 value 类型,保存年龄。
C++11特性支持初始化列表构造和移动构造,比如:
    QMap<QString, int> nameAge{ {"Alice", 20},
                                {"Bob", 22},
                                {"Cell", 19} };
    qDebug()<<nameAge;
    QMap<QString, int> nameAgeOther = std::move( nameAge );
    qDebug()<<nameAge;
    qDebug()<<nameAgeOther;
上面一段代码的输出如下所示:
QMap(("Alice", 20)("Bob", 22)("Cell", 19))
QMap()
QMap(("Alice", 20)("Bob", 22)("Cell", 19))

移动构造函数会将 nameAge 内所有元素都转移给 nameAgeOther,因此 nameAge 最后变成空的,而 nameAgeOther 会包含原本 nameAge 拥有的元素。

std::map 是标准库的映射模板类,包含在 <map> 头文件中,使用方法与 QMap 类似,如果需要从标准库的 map 构造 QMap 对象,可以参照下面代码编写:
    std::map<QString , int>  astdMap{ {"Alice", 20},
                                  {"Bob", 22},
                                  {"Cell", 19} };
    QMap<QString, int> nameAge( astdMap );
注意 std::map 和 QMap 的 key、value 类型必须要一致,才能这样构造。

(2)添加函数
本小节的元素是指一对 key - value ,添加元素后,QMap 内部的红黑树会新加一个节点。
向 QMap 添加新元素有三种方式,第一种通过两个 insert()  函数:
iterator    insert(const Key & key, const T & value) //直接插入一对 key - value
iterator    insert(const_iterator pos, const Key & key, const T & value)//在建议的迭代器 pos 位置插入一对 key - value
第一个 insert() 函数不关心元素插入位置,直接添加到红黑树中;
第二个 insert() 函数是建议在迭代器 pos 位置插入元素,但是建议的位置不一定有效,红黑树是按照 key 大小排序的,实际插入的位置是按照排序规则确定的,pos 位置不一定有效,所以一般插入元素推荐用第一个 insert() 函数。

向 QMap 添加新元素第二种方式,就是运算符重载函数 operator[]() :
T & QMap::​operator[](const Key & key)
上面两种插入元素方式举例:
    QMap<QString, int> nameAge;
    nameAge.insert( "Alice", 20 );
    nameAge["Bob"] = 22;
    nameAge["Cell"] = 19;
中括号的方式用起来更像数组,语法也相对简单一些。
如果 key - value 配对已经存储在映射对象里面了,那么继续用相同 key 调用 insert() 或 operator[]() ,
由于单映射的特性,结果就是 key 不变,而 key 对应的 value 会被新的 value 覆盖。

insert() 或 operator[]() 在映射对象里没有 key 时添加新元素,而当已存在 key 时用新value覆盖旧的value。

向 QMap 添加新元素的第三种方式是 insertMulti() 函数,即红黑树会插入一对多映射节点,放到后面介绍,一般不建议使用。

(3)移除和删除函数
从映射对象卸下一个元素,但不释放空间,使用下面函数:
T    take(const Key & key)
返回值 T 是 value 类型的数值。如果映射对象里根本没有指定 key,那么返回值是 value 类型默认构造函数生成的对象。
如果不需要返回值,直接从映射对象删除指定 key 及其 value,使用下面函数:
int    remove(const Key & key)
返回值是删除元素的个数,如果返回值为 0,说明映射里没有该 value;如果为 1 ,说明正好删除了一对 key - value ;如果返回值大于1,说明程序之前使用 insertMulti() 函数为一个 key 添加了多个 value 值(QMap 允许一对多映射,多个 key-value 元素 的 key 值相同,但一般不建议这样做)。
如果希望清空所有元素,那么使用如下函数:
void    clear()

(4)访问和查询函数
查询映射对象内是否包含 key 键:
bool    contains(const Key & key) const
查询映射对象内所有元素数目:
int    count() const
int    size() const
统计 key 对应的 value 值数量,使用下面函数:
int    count(const Key & key) const
如果映射对象不存在 key 键,那么返回值为 0,如果存在一对 key-value ,那么返回值为 1;如果程序之前使用 insertMulti() 函数为一个 key 添加了多个 value,那么返回值是多个 value 值的数量。
判断映射对象是否全空,没有元素,使用下面两个函数都可以:
bool    empty() const      //STL风格
bool    isEmpty() const   //Qt风格

获取映射中第一个 value 值,使用下面函数:
T &    first()
const T &    first() const
获取映射中第一个 key 键,使用下面函数:
const Key &    firstKey() const
获取映射中最后一个 value 值,使用下面函数:
T &    last()
const T &    last() const
获取映射中最后一个 key 键,使用下面函数:
const Key &    lastKey() const

根据已知 value 值反查归属的 key 键:
const Key    key(const T & value, const Key & defaultKey = Key()) const
反查耗时比较长,需要逐个遍历元素,注意多个 key 对应的 value 可能一样,所以上面函数只返回第一个匹配的 key。如果找不到就返回默认构造的 Key() 。
如果要根据 value 反查所有匹配的 key 键列表,使用下面函数:
QList<Key>    keys(const T & value) const
如果需要获取映射所有元素的 key 值列表,使用下面函数:
QList<Key>    keys() const
注意 insertMulti() 函数可能导致多个 key-value 元素的 key 值一样,keys() 获取的键值是可能重复的。如果希望获取不重复出现的 key 列表,使用下面函数:
QList<Key>    uniqueKeys() const
根据 key 查询对应 value ,使用下面函数:
const T    value(const Key & key, const T & defaultValue = T()) const
如果没有找到 key-value 元素,那么返回 T() 值,就是 value 类型默认构造值。
存在一对多映射的情况下,可以用下面函数获取 key 对应的多个 value 值列表:
QList<T>    values(const Key & key) const
如果要获取映射中所有元素的 value 值列表,使用下面函数:
QList<T>    values() const

(5)交换函数
将映射对象自身的元素与另一个映射对象中的元素全部互换,使用下面函数:
void    swap(QMap<Key, T> & other)
swap() 函数效率非常高,并且从不失败。

(6)运算符函数
对于运算符函数,我们以下面两个映射来举例说明:
    QMap<QString, int> m1;
    m1["Alice"] =  20;
    QMap<QString, int> m2;
    m2["Bob"] = 22;
    m2["Cell"] = 19;
运算符使用示范如下表所示:

运算符函数 举 例 描述
bool operator!=(const QMap<Key, T> & other) const  m1 != m2; 两个映射的元素不一样,不等号判断结果为 true。
bool operator==(const QMap<Key, T> & other) const  m1 == m2; 两个映射的元素不一样,等于号判断结果为 false。
QMap<Key, T> & operator=(const QMap<Key, T> & other)  m1 = m2; 将 m2 所有元素复制给 m1,执行后二者相等。
QMap<Key, T> & operator=(QMap<Key, T> && other)  m1 = std::move(m2); 将 m2 中所有元素移动给m1,m2自己清空。
T & operator[](const Key & key)  m2["Cell"]= 18; 修改了 "Cell" 对应的value值。
const T operator[](const Key & key) const  qDebug()<< m1["Alice"]; 打印 "Alice" 对应的常量值。

(7)迭代器函数
映射类也定义了 STL 风格和 Qt 命名风格的迭代器:
class    const_iterator   //STL风格只读迭代器
class    iterator             //STL风格读写迭代器
typedef    ConstIterator  //Qt 风格只读迭代器
typedef    Iterator          //Qt风格读写迭代器
STL 风格迭代器使用示范:
QMap<QString, int>::const_iterator i = map.constBegin();
while (i != map.constEnd()) {
    cout << i.key() << ": " << i.value() << endl;
    ++i;
}
获取映射的头部元素、尾部假想元素的迭代器函数列举如下:
iterator    begin()     //指向头部的读写迭代器
const_iterator    begin() const            //指向头部的只读迭代器
const_iterator    cbegin() const          //指向头部的只读迭代器
const_iterator    constBegin() const  //指向头部的只读迭代器,Qt风格
iterator    end()       //指向尾部后面假想元素的读写迭代器
const_iterator    end() const             //指向尾部后面假想元素的只读迭代器
const_iterator    cend() const           //指向尾部后面假想元素的只读迭代器
const_iterator    constEnd() const    //指向尾部后面假想元素的只读迭代器,Qt风格
注意 *end() 返回的迭代器只能做不等于判断,它指向的东西根本不存在, *end() 仅用于越界判断。
虽然获取头部、尾部迭代器的函数多,其实功能类似,起了一堆名字是方便兼容 STL 风格函数命名。
查找指定 key 键对应的迭代器位置,使用下面函数:
iterator    find(const Key & key)    //根据指定key查找所在位置的读写迭代器
const_iterator    find(const Key & key) const             //根据指定key查找所在位置的只读迭代器,STL风格
const_iterator    constFind(const Key & key) const    //根据指定key查找所在位置的只读迭代器,Qt风格
如果存在 key 键的一对多映射,返回排在最前面的 key 节点迭代器,相同 key 的多个节点会排在该迭代器之后连续位置;
如果找不到包含指定 key 的元素,那么查找函数返回 end() 尾部虚假元素迭代器,注意判断几个 *find 函数的返回值。
根据读写迭代器指定位置,可以删除该位置元素:
iterator    erase(iterator pos)
删除后返回指向下一元素的迭代器,注意可能是 end() 位置。

QMap 在绝大多数情况下,都是用于一对一映射,但是它也提供了一对多映射的接口函数:
//插入指定键值对,如果之前有该键的元素,那么不会替换旧元素,直接增加新的元素,造成一对多映射
iterator    insertMulti(const Key & key, const T & value)   //插入一对多映射元素
iterator    insertMulti(const_iterator pos, const Key & key, const T & value) //在建议的 pos 位置附近插入一对多映射元素
insertMulti() 会直接向映射添加键值对,并且不会替换旧的相同键值节点,所以会造成多个节点拥有相同的键值,一般不建议这样调用,Qt 专门封装了 QMultiMap 类用于处理一对多映射。

由于 insertMulti() 会造成一对多映射,红黑树是排序树,同样的 key 键节点是按照排序相邻的,迭代器位置是连续排布的,可以获取一个 key 对应的多个元素迭代器范围:
QPair<iterator, iterator>    equal_range(const Key & key)  //返回一对迭代器
//QPair<iterator, iterator>  中,第一个迭代器是排在最前面的key键节点位置,第二个是排在最后的key键节点位置

根据红黑树的排序特性,QMap 还提供了查找 key 下边界和上边界的迭代器函数:
iterator    lowerBound(const Key & key)      //查找 key 下边界的读写迭代器
const_iterator    lowerBound(const Key & key) const //查找 key 下边界的只读迭代器
iterator    upperBound(const Key & key)    //查找 key 上边界的读写迭代器
const_iterator    upperBound(const Key & key) const //查找 key 上边界的只读迭代器
key 下边界的意思是按照从小到大顺序,找到红黑树中首个满足如下条件的 keyLB 节点: 
keyLB >= key
如果映射存在 key 节点,那么返回第一个键值等于 key 的节点迭代器;
如果没有 key 节点,那么返回首个大于 key 的节点迭代器。举例如下:
QMap<int, QString> map;
map.insert(1, "one");
map.insert(5, "five");
map.insert(10, "ten");

map.lowerBound(0);      // returns iterator to (1, "one")
map.lowerBound(1);      // returns iterator to (1, "one")
map.lowerBound(2);      // returns iterator to (5, "five")
map.lowerBound(10);     // returns iterator to (10, "ten")
map.lowerBound(999);    // returns end()
key 上边界的意思是按照从小到大顺序,找到红黑树中首个满足如下条件的节点 keyUB:
keyUB > key
上边界总是返回大于 key 的最邻近节点迭代器。
举例如下:
QMap<int, QString> map;
map.insert(1, "one");
map.insert(5, "five");
map.insert(10, "ten");

map.upperBound(0);      // returns iterator to (1, "one")
map.upperBound(1);      // returns iterator to (5, "five")
map.upperBound(2);      // returns iterator to (5, "five")
map.upperBound(10);     // returns end()
map.upperBound(999);    // returns end()

(8)容器类型转换函数
Qt 提供了映射类,STL 也有自己映射类,两种映射类互相转换的函数如下:
std::map<Key, T>    toStdMap() const  //转为 STL 映射类
QMap(const std::map<Key, T> & other) //构造函数,根据 STL 映射构造 QMap 映射
QMap 另外支持两个映射合并,将参数 other 映射的元素全部复制添加给自己,如果两个映射都包含相同的 key,那么合并类似 insertMulti() 造成一对多映射:
QMap<Key, T> &    unite(const QMap<Key, T> & other)
insertMulti() 和 unite() 会无脑添加新元素,即使新的键值对与旧节点完全一样,比如:
    QMap<QString, int> m1;
    m1["Alice"] =  20;
    QMap<QString, int> m2;
    m2["Alice"] =  20;

    m1.unite( m2 );
    m1.insertMulti("Alice",20 );

    qDebug()<<m1<<endl<<m2;
打印结果是 m1 包含三个相同节点:
QMap(("Alice", 20)("Alice", 20)("Alice", 20))
QMap(("Alice", 20))

(9)其他内容
映射类也支持数据串行化,进行数据流输入和输出,但注意前提是 key 和 value 的类型都必须支持串行化:
QDataStream &    operator<<(QDataStream & out, const QMap<Key, T> & map)  //串行化输出
QDataStream &    operator>>(QDataStream & in, QMap<Key, T> & map)               //串行化输入

关于 QMap,这里再提醒两个注意事项:
① 不能使用 map[key] 这种形式查找映射里是否包含键 key 的元素,因为 operator[](const Key & key) 函数在找不到 key 元素时,自动调用 value 类默认构造函数为映射添加 key-value 新元素。
应该用 contains(key) 来判断是否包含该 key 元素,或者用  map.value( key ) 函数查找值,value() 函数不会为映射添加新元素,虽然 value() 函数找不到时也会返回 value 类型默认构造的值,但不会改变映射内容。

② 一般不建议使用 insertMulti() 和 unite() 进行多重映射添加或映射合并,Qt 单独提供了 QMultiMap 表示多重映射,在程序中尽量让 QMap 保持一对一映射,避免代码的误解。

下面开始本小节的示例程序:
我们打开 QtCreator,新建一个 Qt Widgets Application 项目,在新建项目的向导里填写:
①项目名称 nameage,创建路径 D:\QtProjects\ch09,点击下一步;
②套件选择里面选择全部套件,点击下一步;
③基类选择 QWidget,点击下一步;
④项目管理不修改,点击完成。
我们打开 widget.ui 界面文件,按照下图拖入控件:
ui
我们首先将窗口宽度设为 480,高度 300,这样能放下四个并排的按钮,然后逐个拖入控件:
第一行是标签控件,文本为 "姓名-年龄映射" 。
第二行为列表控件,对象名 listWidget。
第三行控件为:标签 "姓名",单行编辑器 lineEditName,标签 "年龄",旋钮编辑框 spinBoxAge,第三行控件按水平布局器排列。注 意设置旋钮编辑框的 sizePolicy 属性,将水平策略设置为 Expanding。
第四行为四个按钮:"添加元素" 按钮 pushButtonAdd,"删除匹配姓名元素" 按钮 pushButtonDel,"查找匹配姓名元素" 按钮 pushButtonFindName,"查找匹配年龄元素" 按钮 pushButtonFindAge,四个按钮也使用水平布局排列。
第五行是丰富文本编辑框,对象名 textEdit,该编辑框默认文本设置为 "结果显示" 。
窗口整体使用垂直布局,窗口大小 480*300 。

控件布局设置好之后,我们依次右键点击 4 个按钮,在右键菜单选择“转到槽...”,弹出如下对话框:
slot
选择信号 clicked() ,点击 OK 按钮,为 4 个按钮都添加对应的槽函数。
槽函数添加完成后,我们保存界面文件,关闭界面文件,然后对头文件 widget.h 进行编辑:
#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include <QMap> //映射类

namespace Ui {
class Widget;
}

class Widget : public QWidget
{
    Q_OBJECT

public:
    explicit Widget(QWidget *parent = 0);
    ~Widget();

private slots:
    void on_pushButtonAdd_clicked();

    void on_pushButtonDel_clicked();

    void on_pushButtonFindName_clicked();

    void on_pushButtonFindAge_clicked();

private:
    Ui::Widget *ui;
    //映射类对象,保存姓名-年龄映射
    QMap<QString, int> m_mapNameAge;
    //枚举映射对象的内容,显示到列表控件
    void showNameAgeMap();
};

#endif // WIDGET_H
在文件开头,我们添加了 QMap 类的头文件包含;
Widget 类内部有 4 个槽函数是通过右键菜单添加的;
Widget 类末尾添加了映射类对象 m_mapNameAge,key 类型为 QString,value 类型为 int;
然后添加了 showNameAgeMap() 函数,专门枚举映射对象的内容,显示到界面的列表控件。

接下来我们分段编辑源文件 widget.cpp 的内容,首先是构造函数和析构函数部分:
#include "widget.h"
#include "ui_widget.h"
#include <QDebug>
#include <QMessageBox>

Widget::Widget(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::Widget)
{
    ui->setupUi(this);
    //设置年龄范围
    ui->spinBoxAge->setRange(0, 600);
    //结果显示框设置只读
    ui->textEdit->setReadOnly(true);
    //初始化添加几个元素到映射
    m_mapNameAge.insert("Alice", 20);
    m_mapNameAge.insert("Bob", 23);
    m_mapNameAge.insert("Cass", 23);
    m_mapNameAge.insert("Daff", 21);
    //显示映射到列表控件
    showNameAgeMap();
}

Widget::~Widget()
{
    delete ui;
}
文件开头添加了调试信息类和消息框类的头文件包含。
构造函数里添加了几行代码,首先将年龄控件 spinBoxAge 的取值范围设置为 0~600 ;
设置文本编辑框 textEdit 为只读模式,避免用户修改结果编辑框内容;
然后为成员变量  m_mapNameAge 添加了四个键值对;
构造函数最后调用 showNameAgeMap() 将映射对象的内容显示到列表控件。
析构函数的代码没有修改,下面我们来编辑 showNameAgeMap() 函数代码:
void Widget::showNameAgeMap()
{
    ui->listWidget->clear();    //清空旧内容
    //获取所有 key 的列表
    QList<QString> listKeys = m_mapNameAge.keys();
    int nCount = listKeys.count();
    //遍历
    for(int i=0; i<nCount; i++)
    {
        //根据 key-value 构造一行字符串
        QString curText = tr("%1\t%2").arg( listKeys[i] ).arg( m_mapNameAge[ listKeys[i] ] );
        //添加到列表控件
        ui->listWidget->addItem( curText );
    }
}
showNameAgeMap() 内部先清空了列表控件内容;
获取 m_mapNameAge 映射所有的键列表;
所有键的数量也就是映射中元素的个数,将数量保存到 nCount ;
然后循环遍历所有的键、值内容,构造文本,添加给 listWidget 。
showNameAgeMap() 是通过获取所有键列表的方式遍历映射对象,也可以直接用迭代器方式遍历,在上面迭代器函数介绍部分有示范代码。

接下来逐个编辑按钮槽函数的代码,首先是“添加”按钮的槽函数:
void Widget::on_pushButtonAdd_clicked()
{
    //检查姓名 key ,不能为空
    QString strName = ui->lineEditName->text().trimmed();
    if( strName.isEmpty() )
    {
        QMessageBox::warning(this, tr("检查姓名key"), tr("姓名为空,不能添加。"));
        return;
    }
    //添加姓名-年龄对
    m_mapNameAge[ strName ] = ui->spinBoxAge->value();
    //显示
    showNameAgeMap();
    ui->textEdit->setText( tr("已添加姓名-年龄新元素。") );
}
该槽函数首先获取姓名编辑框的字符串,存到 strName ,并判断字符串是否为空,空字符串不处理直接返回;
对于非空字符串,继续后面代码;
使用中括号的方式,为映射 m_mapNameAge 添加键值对;
然后调用  showNameAgeMap() 显示添加新元素后的映射到列表控件;
最后在结果显示编辑框里,显示已添加新元素的信息。

“删除匹配姓名元素”按钮槽函数代码如下:
void Widget::on_pushButtonDel_clicked()
{
    //检查姓名 key ,不能为空
    QString strName = ui->lineEditName->text().trimmed();
    if( strName.isEmpty() )
    {
        QMessageBox::warning(this, tr("检查姓名key"), tr("姓名为空,不能删除。"));
        return;
    }
    //查找是否存在该 key
    if( ! m_mapNameAge.contains( strName ) )
    {
        ui->textEdit->setText( tr("指定姓名不存在,无法删除。") );
        return;
    }
    //删除匹配 key 的元素
    m_mapNameAge.remove( strName );
    //显示
    showNameAgeMap();
    ui->textEdit->setText( tr("指定姓名元素已经删除。") );
}
该槽函数开头类似的获取姓名编辑框的文本,并判断是否为空,空字符串不处理,对于非空字符串才进行后续处理;
调用 m_mapNameAge.contains() 函数判断映射里是否存在键 strName  ,如果不存在就不处理;
如果存在键 strName  ,那么调用   m_mapNameAge.remove() 删除匹配的元素;
最后更新列表控件的显示,并将已经删除元素的信息到结果编辑框。

添加和删除操作修改了映射  m_mapNameAge 的内容,因此需要调用  showNameAgeMap() 更新列表控件的显示,后面的查询按钮操作没有修改映射内容,就不需要更新列表控件。

“查找匹配姓名元素”按钮的槽函数代码如下:
void Widget::on_pushButtonFindName_clicked()
{
    //检查姓名 key ,不能为空
    QString strName = ui->lineEditName->text().trimmed();
    if( strName.isEmpty() )
    {
        QMessageBox::warning(this, tr("检查姓名key"), tr("姓名为空,不能查找。"));
        return;
    }
    //查找是否存在该 key
    if( ! m_mapNameAge.contains( strName ) )
    {
        ui->textEdit->setText( tr("指定姓名不存在。") );
        return;
    }
    //找到了,这里是一对一映射,一个 key 只有一个 value
    QString strResult = tr("已找到指定姓名为 %1 的元素,年龄为 %2")
            .arg(strName).arg( m_mapNameAge[strName] );
    ui->textEdit->setText( strResult );
}
该槽函数类似地先获取姓名字符串,并判断是否为空,空字符串不处理,非空字符串才进行后面处理;
调用  m_mapNameAge.contains() 判断映射是否包含键 strName ,
如果不包含键就显示 "指定姓名不存在。" 的信息到结果编辑框;
如果包含,就显示已找到的信息到结果编辑框。
本示例是一对一的映射,映射中所有 key 都是唯一的,所以一个 key 只有一个 value,不需要考虑多重映射。

最后是“查找匹配年龄元素”按钮的槽函数代码:
void Widget::on_pushButtonFindAge_clicked()
{
    //获取年龄
    int nAge = ui->spinBoxAge->value();
    //根据年龄反查姓名,可能存在多个同龄人
    QList<QString>  listNames = m_mapNameAge.keys( nAge );
    //检查是否找到了
    QString strResult;
    int nCount = listNames.count();
    if( nCount < 1  )
    {
        strResult = tr("没有匹配该年龄的元素。");
    }
    else//存在指定年龄的元素
    {
        strResult = tr("找到了匹配年龄的元素 %1 个,列举如下:\r\n").arg( nCount );
        for(int i=0; i<nCount; i++)
        {
            strResult += tr("%1\t%2\r\n").arg(listNames[i]).arg(nAge);
        }
    }
    //显示结果
    ui->textEdit->setText( strResult );
}
这是个反查函数,根据 value 反查有几个 key。一对一映射的 key 唯一,但是多个 key 可以有相同的 value 值,比如多个人姓名不同,年龄相同。
该函数先获取年龄旋钮框的数值 nAge;
调用 m_mapNameAge.keys( nAge ) 根据年龄反查匹配的所有 key 列表;
然后获取反查的 key 列表中计数 nCount;
如果计数 nCount 小于 1,说明没有找到,设置结果字符串为 "没有匹配该年龄的元素。";
否则有匹配的元素,那么通过循环遍历所有匹配的键值对,构造结果字符串;
最后显示结果字符串到结果编辑框。
示例代码就是上面内容,我们保存代码文件,构建并运行示例:
run1
我们在窗口构造函数添加的四个映射元素显示在了列表控件里。
我们设置年龄为 23 ,然后点击“查找匹配年龄元素”按钮,可以看到反查结果:
run2
其他功能读者都可以自行测试一下,注意示例中映射的 key 是区分字母大小写的,大写字母的键排在前面,小写字母的键排在后面。本小节的内容到这,我们下面小节介绍多映射 QMultiMap 的内容。

9.3.2 多映射 QMultiMap

QMultiMap 是 QMap 的派生类,继承了 QMap 绝大多数的功能函数,同时也根据一对多映射的特性做了改进,将基类的部分函数功能进行了重载,使用 QMultiMap  时需要注意与基类的区别。除了基类的功能函数,QMultiMap 类的函数主要有如下几个:
(1)构造函数
QMultiMap() //默认构造函数
QMultiMap(std::initializer_list<std::pair<Key, T> > list) //初始化列表构造函数
QMultiMap(const QMap<Key, T> & other) //复制构造函数,支持从 QMap 和 QMultiMap 构造新对象
第一个是不带参数的默认构造函数;第二个是支持 C++11 特性的初始化列表构造函数;
第三个是复制构造函数,参数里无论是 QMap 对象或 QMultiMap 对象都可以进行复制构造。
QMultiMap 也是支持移动构造函数的,从基类自动继承,比如下面代码:
    QMultiMap<QString, QString> namePhone{
        {"Alice", "10086"},
        {"Alice", "10087"},
        {"Bob", "10010"},
        {"Bob", "10011"}
    };
    qDebug()<<namePhone;
    QMultiMap<QString, QString> namePhone2( namePhone );
    qDebug()<<namePhone2;

    QMultiMap<QString, QString> namePhone3 =  std::move(namePhone);
    qDebug()<<namePhone<<endl<<namePhone3;
示例代码中三个对象依次使用初始化列表构造、复制构造和移动构造,打印结果如下:
QMap(("Alice", "10087")("Alice", "10086")("Bob", "10011")("Bob", "10010"))
QMap(("Alice", "10087")("Alice", "10086")("Bob", "10011")("Bob", "10010"))
QMap()
QMap(("Alice", "10087")("Alice", "10086")("Bob", "10011")("Bob", "10010"))
QMultiMap 的打印函数自动使用了基类的版本,所以看到类名是 QMap,其实是 QMultiMap  对象。

(2)添加函数
QMap<Key, T>::iterator QMultiMap::​insert(const Key & key, const T & value)
QMap<Key, T>::iterator QMultiMap::​insert(QMap<Key, T>::const_iterator pos, const Key & key, const T & value)
QMultiMap 的迭代器完全从基类 QMap 继承,因此可以看到参数和返回值的迭代器都是 QMap 的迭代器。但要注意 QMultiMap::​insert() 总是插入新的 key-value 节点,不会对旧节点进行替换,即使新旧节点键值一模一样,也会增加新的节点。
第一个 ​insert() 自动添加新节点到红黑树的排序位置,红黑树只按照 key 排序,同样 key 的多个 value 值不会排序,同样 key 的新节点总是插入到同样 key 旧节点的最前面。
第二个 insert() 会在建议的迭代器位置 pos 附近插入新节点,但不一定是指定位置,最终还是要按红黑树的 key 进行排序确定位置。
(3)删除函数
int    remove(const Key & key, const T & value)
int    remove(const Key & key)
第一个删除函数会删除所有键为 key、值为 value 的节点,返回值是删除的个数,因为多映射对象中可以插入多个相同键且相同值的节点,所以第一个删除函数返回值可能大于 1 。
第二个删除函数会删除所有键为 key 的节点,返回值是删除的个数。两个删除函数在找不到匹配节点时,不删除任何东西,返回值是 0 。
(4)访问和查询函数
统计多映射对象所有节点个数使用下面函数:
int count() const
统计所有键为 key 且值为 value 的节点数使用下面函数:
int count(const Key & key, const T & value) const
统计所有键为 key 的节点数,使用下面函数:
int count(const Key & key) const
判断多映射对象是否包含 key-value 对的函数如下:
bool contains(const Key & key, const T & value) const
判断多映射对象是否包含 key 的函数如下:
bool contains(const Key & key) const

根据 key-value 对查找匹配节点的迭代器位置函数如下:
QMap<Key, T>::const_iterator    constFind(const Key & key, const T & value) const //只读迭代器查询,Qt风格函数名
QMap<Key, T>::const_iterator    find(const Key & key, const T & value) const  //只读迭代器,STL风格函数名
QMap<Key, T>::iterator    find(const Key & key, const T & value)  //读写迭代器查询
根据 key 查找匹配节点的迭代器位置函数如下:
QMap<Key, T>::const_iterator    constFind(const Key & key) const  //只读迭代器查询,Qt风格函数名
QMap<Key, T>::const_iterator    find(const Key & key) const  //只读迭代器,STL风格函数名
QMap<Key, T>::iterator    find(const Key & key)  //读写迭代器查询

(5)替换和交换函数
多映射的节点替换函数如下:
QMap<Key, T>::iterator QMultiMap::​replace(const Key & key, const T & value)
节点替换函数在查找到匹配 key 的一个或多个节点时,替换之前最后一次插入的匹配 key 节点;
如果找不到匹配 key 的节点,那么会新增一个 key-value 节点。
多映射与其他同类对象的交换函数如下:
void QMultiMap::​swap(QMultiMap<Key, T> & other)
swap() 函数不会失败,并且效率非常高。

(6)运算符函数
QMultiMap 新加了 + 和 += 运算符函数,用于合并对象:
QMultiMap QMultiMap::​operator+(const QMultiMap & other) const
QMultiMap & QMultiMap::​operator+=(const QMultiMap & other)
合并后的对象节点数总是等于合并前两个对象节点数之和, 两个对象同样 key-value 的节点不会替换,节点数量直接重复累加。
另外 QMultiMap 取消了 operator[] 运算符函数,由于多映射的 key 很可能对应多个 value,同样 key 的多个节点定位不明确,所以不能用 operator[] 运算符函数。替换之前最新插入的键为 key 的节点使用 replace() 函数。

QMap 和 QMultiMap 二者功能函数的主要区别对比如下表所示:

功能 QMap 函数 QMultiMap 函数
一对一添加节点 insert(key,value):无匹配key时直接插入新节点,有匹配key时替换旧节点。 replace(key,value):无匹配key时直接插入新节点,有匹配key时,替换之前最新插入的同样key节点。
一对多添加节点 insertMulti(key,value):直接将新节点插入到红黑树,不考虑之前有无同样键值的节点。 insert(key,value):直接将新节点插入到红黑树,不考虑之前有无同样键值的节点。
insertMulti(key,value)函数同基类。
中括号运算符 operator[](key):根据key读写匹配的节点,如果没有匹配的,自动添加该 key 节点。 没有中括号运算符,对于类似功能,读操作调用 value(key)函数,写操作调用replace(key,value)。
合并两个对象 无 + 和 += 运算符函数。QMap::​unite(other)可以将参数other所有节点添加给自己,类似 += 功能。 通过 + 和 += 运算符函数。
查询函数 count(key)、contains(key)、find(key)、constFind(key),只需要通过 key 查询节点,因为通常是一对一映射。 不仅有 count(key)、contains(key)、find(key)、constFind(key),一对多映射查询时还可以根据键值对进行查询
count(key,value)、contains(key,value)、find(key,value)、constFind(key,value)。
删除函数 remove(key),删除匹配 key 的节点。 两个删除函数,remove(key)删除匹配 key 的所有节点,remove(key,value)删除匹配 key-value 的所有节点。

需要特别注意的就是 insert() 函数,基类 QMap 和 派生类 QMultiMap 的 insert() 函数名一样,功能却不一样,基类 QMap 是一对一添加或替换,而派生类 QMultiMap 是一对多的重复添加。

QMultiMap 的功能函数介绍到这,我们下面学习一个电话号码本的示例,将姓名映射到多个电话号码。
我们打开 QtCreator,新建一个 Qt Widgets Application 项目,在新建项目的向导里填写:
①项目名称 namephone,创建路径 D:\QtProjects\ch09,点击下一步;
②套件选择里面选择全部套件,点击下一步;
③基类选择 QWidget,点击下一步;
④项目管理不修改,点击完成。
我们打开 widget.ui 界面文件,按照下图拖入控件:
ui
第一行是标签控件,文本为“姓名-电话映射”。
第二行是列表控件,对象名为 listWidget。
第三行是标签“姓名”,单行编辑器 lineEditName,标签“电话”,单行编辑器 lineEditPhone,第三行按水平布局器排布。
第四行和第五行是 6 个按钮,依次为 “添加元素”按钮 pushButtonAdd、“替换元素”按钮 pushButtonReplace、“删除匹配姓名”按钮 pushButtonDelName、“删除匹配姓名电话”按钮 pushButtonDelNamePhone,“查询姓名”按钮 pushButtonFindName、“查询电话”按钮 pushButtonFindPhone,第四行和第五行使用一个网格布局器排布。
第六行是文本编辑框 textEdit 。
窗口整体布局使用垂直布局器,窗口大小 400*400 。

控件布局设置好之后,我们依次右键点击 6 个按钮,在右键菜单选择“转到槽...”,弹出如下对话框:
slot
选择信号 clicked() ,点击 OK 按钮,为 6 个按钮都添加对应的槽函数。
槽函数添加完成后,我们保存界面文件,关闭界面文件,然后对头文件 widget.h 进行编辑:
#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include <QMultiMap>//多重映射模板类

namespace Ui {
class Widget;
}

class Widget : public QWidget
{
    Q_OBJECT

public:
    explicit Widget(QWidget *parent = 0);
    ~Widget();

private slots:
    void on_pushButtonAdd_clicked();

    void on_pushButtonReplace_clicked();

    void on_pushButtonDelName_clicked();

    void on_pushButtonDelNamePhone_clicked();

    void on_pushButtonFindName_clicked();

    void on_pushButtonFindPhone_clicked();

private:
    Ui::Widget *ui;
    //多重映射对象,保存姓名电话映射
    QMultiMap<QString, QString> m_mmapNamePhone;
    //枚举映射对象内容,显示到列表控件
    void showNamePhoneMap();
};

#endif // WIDGET_H
widget.h 文件中,开头添加了多重映射模板类的头文本包含;
Widget 类声明中,6 个槽函数是通过右键菜单添加的;
声明末尾手动添加了多重映射对象 m_mmapNamePhone,保存姓名到电话的映射关系;
手动添加了函数 showNamePhoneMap(),将姓名电话映射的内容显示到窗口的列表控件。

接下来我们分段编辑 widget.cpp 源文件内容,添加功能代码,首先是构造函数、析构函数部分:
#include "widget.h"
#include "ui_widget.h"
#include <QDebug>
#include <QMessageBox>
#include <QRegExp> //正则表达式
#include <QRegExpValidator>//正则表达式验证器

Widget::Widget(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::Widget)
{
    ui->setupUi(this);
    //设置电话号码的限定,这里用正则表达式粗略限定 3 ~ 14 位数字
    QRegExp re("[0-9]{3,14}");
    QValidator *vali = new QRegExpValidator(re);
    ui->lineEditPhone->setValidator( vali );
    //结果显示框设为只读
    ui->textEdit->setReadOnly(true);
    //添加几个多重映射元素
    m_mmapNamePhone.insert("Alice", "10086");
    m_mmapNamePhone.insert("Alice", "10086");
    m_mmapNamePhone.insert("Bob", "10010");
    m_mmapNamePhone.insert("Bob", "10011");
    m_mmapNamePhone.insert("Ceil", "12345");
    //显示多重映射到列表控件
    showNamePhoneMap();
}

Widget::~Widget()
{
    delete ui;
}
widget.cpp 开头添加了调试类、消息框、正则表达式和正则表达式验证器等头文件包含,正则表达式用于检查电话号码格式。
在构造函数中,定义了一个简单的正则表达式 re,限定 3~14 位的电话号码,实际中的电话号码更复杂,这里使用简单的版本;然后新建了正则表达式验证器 vali,设置给电话号码的编辑框 ui->lineEditPhone;
设置结果显示框 ui->textEdit 为只读模式;
为多重映射对象添加了五个元素,注意键 "Alice" 和 值 "10086" 添加了两次,会生成两个元素,而不会覆盖。
构造函数最后调用 showNamePhoneMap() 显示映射的内容到列表控件。
析构函数没有修改,使用默认代码。

接下来手动添加 showNamePhoneMap() 函数实体代码:
//显示多重映射到列表控件
void Widget::showNamePhoneMap()
{
    //清空旧的内容
    ui->listWidget->clear();
    //使用迭代器遍历
    QMultiMap<QString, QString>::iterator it = m_mmapNamePhone.begin();
    //循环遍历直到结束
    while( it != m_mmapNamePhone.end() )
    {
        //读取键、值,拼接为字符串
        QString curText = tr("%1\t%2").arg( it.key() ).arg( it.value() );
        //添加到列表控件
        ui->listWidget->addItem( curText );
        //递增迭代器
        it++;
    }
}
该函数先清空列表控件的旧内容;
定义迭代器 it,初始为  m_mmapNamePhone 映射对象的开始位置;
然后循环遍历映射对象,根据键 it.key() 和值 it.value() 构造字符串,添加给列表控件,
循环末尾使用 it++ 递增迭代器位置,进行下一个元素的访问。
当 it 等于 m_mmapNamePhone.end() 时,说明遍历结束。

注意迭代器遍历时,要使用 it++ 或 ++it 移动到下一个元素,不移动位置会导致死循环;
另外 m_mmapNamePhone.end() 指向末尾假想元素位置,就是没有指向任何元素,不能访问该迭代器的键或值。

接下来依次编辑各个功能按钮的槽函数代码,首先是“添加元素”按钮的槽函数代码:
void Widget::on_pushButtonAdd_clicked()
{
    //获取姓名、电话
    QString strName = ui->lineEditName->text().trimmed();
    QString strPhone = ui->lineEditPhone->text().trimmed();
    //两个字符串不能为空
    if( strName.isEmpty() || strPhone.isEmpty() )
    {
        QMessageBox::warning(this, tr("检查姓名和电话"), tr("姓名和电话都不能为空!"));
        return;
    }
    //多重映射的添加
    m_mmapNamePhone.insert(strName, strPhone);
    //显示
    showNamePhoneMap();
    ui->textEdit->setText( tr("已添加姓名-电话新元素。") );
}
该函数先获取姓名编辑框、电话编辑框的文本,然后判断两个文本 strName、strPhone 是否为空:
如果为空就显示消息框,提示两个文本都不能为空,然后返回;
如果非空就继续后面代码,调用 m_mmapNamePhone.insert(strName, strPhone) 为映射添加新元素;
然后调用 showNamePhoneMap() 更新列表控件的显示,并将结果编辑框的文本更新。
多重映射的 insert() 函数一定会为映射添加新的元素,而不会覆盖同 key 同 value 的旧元素。

“替换元素”按钮的槽函数代码如下:
void Widget::on_pushButtonReplace_clicked()
{
    //获取姓名、电话
    QString strName = ui->lineEditName->text().trimmed();
    QString strPhone = ui->lineEditPhone->text().trimmed();
    //两个字符串不能为空
    if( strName.isEmpty() || strPhone.isEmpty() )
    {
        QMessageBox::warning(this, tr("检查姓名和电话"), tr("姓名和电话都不能为空!"));
        return;
    }
    //多重映射的替换操作,如果没有旧key,会新增元素
    m_mmapNamePhone.replace(strName, strPhone);
    //显示
    showNamePhoneMap();
    ui->textEdit->setText( tr("已完成姓名-电话元素替换。") );
}
“替换按钮”的槽函数代码非常类似“添加元素”按钮的槽函数代码,只是将多重映射的 insert() 函数换成了 replace() 函数。多重映射的 replace() 函数在能找到 同 key 元素的情况下,替换之前最近插入的同 key 元素,这时候多重映射元素的数量不会增加;如果找不到同 key 元素,那么自动添加新元素,这时候多重映射的元素数量增加一个。

“删除匹配姓名”按钮的槽函数代码如下:
void Widget::on_pushButtonDelName_clicked()
{
    //获取姓名
    QString strName = ui->lineEditName->text().trimmed();
    //字符串不能为空
    if( strName.isEmpty() )
    {
        QMessageBox::warning(this, tr("检查姓名"), tr("姓名不能为空!"));
        return;
    }
    //可以直接调用删除函数,返回值是删除数量
    int nRet = m_mmapNamePhone.remove( strName );
    if( nRet < 1 )
    {
        //没有删除东西,不需要更新列表控件
        ui->textEdit->setText( tr("指定姓名不存在,无法删除。") );
    }
    else
    {
        //更新列表控件、结果显示框
        showNamePhoneMap();
        ui->textEdit->setText( tr("已删除匹配姓名元素 %1 个。").arg(nRet) );
    }
}
该函数先获取姓名编辑框的文本,并判断 strName 是否为空,如果为空就显示消息框,然后返回;
如果姓名文件非空,那么继续后面代码。
QMap 和 QMultiMap 的 remove()  函数都可以直接调用,不需要判断是否包含 key , remove()  函数返回值是删除元素的数量,如果为 0 说明没有匹配的元素,如果是 1 个或以上,说明删除了返回值数量的匹配元素。
上面槽函数在调用 m_mmapNamePhone.remove( strName ) 之后,判断返回值:
如果小于 1,说明没有匹配元素,映射对象没有变化,直接显示结果文本,而不需要更新列表控件;
如果大于等于 1,说明删除了匹配的元素,调用 showNamePhoneMap() 更新列表控件显示,然后在结果框显示删除元素的个数。

“删除匹配姓名电话”按钮的槽函数代码如下:
void Widget::on_pushButtonDelNamePhone_clicked()
{
    //获取姓名、电话
    QString strName = ui->lineEditName->text().trimmed();
    QString strPhone = ui->lineEditPhone->text().trimmed();
    //两个字符串不能为空
    if( strName.isEmpty() || strPhone.isEmpty() )
    {
        QMessageBox::warning(this, tr("检查姓名和电话"), tr("姓名和电话都不能为空!"));
        return;
    }
    //可以直接调用删除函数,返回值是删除数量
    int nRet = m_mmapNamePhone.remove( strName, strPhone );
    if( nRet < 1 )
    {
        //没有删除东西,不需要更新列表控件
        ui->textEdit->setText( tr("指定姓名电话元素不存在,无法删除。") );
    }
    else
    {
        //更新列表控件,结果显示框
        showNamePhoneMap();
        ui->textEdit->setText( tr("已删除匹配姓名电话元素 %1 个。").arg(nRet) );
    }
}
该函数先获取姓名、电话编辑框的文本,并判断是否为空,如果为空就显示消息框后返回;
如果 strName 和 strPhone 都非空,继续后面代码。
调用 m_mmapNamePhone.remove( strName, strPhone ) 删除同时匹配姓名和电话的元素,返回值是删除的数量。
判断返回值 nRet,如果小于 1,说明没有删除元素,直接显示结果框的文本;
如果大于等于 1,那么调用 showNamePhoneMap() 更新列表控件显示,并显示删除数量到结果框。

基类 QMap 只提供了一个 remove( key ) 删除函数,而派生类 QMultiMap 提供了两个删除函数:
remove( key ) 和 remove( key, value ),双参数版本的删除函数用于在同时匹配 key 和 value 的情况下删除元素。
QMultiMap 的 find() 、count()、 contains() 类似的都有单参数版本和双参数版本,单参数版本函数仅匹配 key,而双参数版本同时匹配 key  和 value。基类 QMap 通常用于一对一映射,一个 key 绑定一个 value,所以不需要双参数的版本。

“查询姓名”按钮的槽函数代码如下:
void Widget::on_pushButtonFindName_clicked()
{
    //获取姓名
    QString strName = ui->lineEditName->text().trimmed();
    //姓名不能为空
    if( strName.isEmpty() )
    {
        QMessageBox::warning(this, tr("检查姓名"), tr("姓名不能为空!"));
        return;
    }
    //查找姓名对应的电话列表,如果电话列表为空说明没有匹配的key
    QList<QString> listPhones = m_mmapNamePhone.values( strName );
    QString strResult; //结果字符串
    int nPhonesCount = listPhones.count();
    //检查数量
    if( nPhonesCount < 1 )
    {
         strResult = tr("没有找到指定姓名元素。");
    }
    else
    {
        strResult = tr("已找到匹配姓名元素 %1 个:\r\n").arg( nPhonesCount );
        for(int i=0; i<nPhonesCount; i++)
        {
            strResult += tr("%1\t%2\r\n").arg( strName ).arg( listPhones[i] );
        }
    }
    //显示结果字符串
    ui->textEdit->setText( strResult);
}
该函数先获取姓名字符串的文本,检查是否为空,如果为空就显示消息框后返回;
如果非空,那么继续后面代码。
调用 m_mmapNamePhone.values( strName ) 查询匹配键 strName 的所有值列表;
定义结果字符串 strResult;
获取列表 listPhones 的元素计数 nPhonesCount ;
判断计数 nPhonesCount ,如果小于 1 ,说明没有映射中没有匹配的键,设置相应 strResult 内容;
如果大于等于 1,那么先为 strResult 设置第一行文本,说明匹配个数,
然后循环遍历 listPhones 的值列表,将映射中匹配的键值元素逐行添加到 strResult 。
最后显示结果字符串到文本框 ui->textEdit 。

QMultiMap 的 values() 函数是从基类 QMap 继承的,由于 QMap 通常是一对一映射,所以 QMap 有 values() 函数也很少用。这个 values() 函数其实是为多重映射定制的,更多地用于 QMultiMap 查询匹配 key 的所有 value 列表。如果返回列表的元素计数为 0,那么说明没有找到匹配 key 的元素,如果列表存在 1 个或以上元素,说明找到了所有匹配元素的 value 。

“查询电话”按钮的槽函数代码如下:
void Widget::on_pushButtonFindPhone_clicked()
{
    //获取电话
    QString strPhone = ui->lineEditPhone->text().trimmed();
    //电话不能为空
    if( strPhone.isEmpty() )
    {
        QMessageBox::warning(this, tr("检查电话"), tr("电话不能为空!"));
        return;
    }
    //反向查找,根据value反查key,姓名电话可能重复多个
    QList<QString> listNames = m_mmapNamePhone.keys( strPhone );
    QString strResult; //结果字符串
    int nNamesCount = listNames.count();
    //检查数量
    if( nNamesCount < 1 )
    {
        strResult = tr("没有找到匹配电话的元素。");
    }
    else
    {
        strResult = tr("已找到匹配电话的元素 %1 个:\r\n").arg( nNamesCount );
        for(int i=0; i<nNamesCount; i++)
        {
            strResult += tr("%1\t%2\r\n").arg( listNames[i] ).arg( strPhone );
        }
    }
    //显示结果
    ui->textEdit->setText( strResult );
}
该函数先获取电话编辑框的文本,判断是否为空,如果为空,显示消息框,然后返回;
如果文本 strPhone 非空,继续后面代码。
调用 m_mmapNamePhone.keys( strPhone ) ,根据值 strPhone 反向查找匹配的 key 列表,同样的电话可能匹配多个姓名,比如公司的公用电话。keys() 函数返回匹配该值的所有键列表。
然后定义结果字符串 strResult;
获取键列表的计数保存到 nNamesCount;
然后对计数 nNamesCount 进行判断,如果小于 1,那么说明没有找到匹配的元素,设置相应的结果字符串;
如果大于等于 1,那么先设置 strResult 的第一行文本,说明匹配电话元素的计数,
然后循环遍历 listNames 列表,将列表的姓名和查询的电话字符串拼接成一行,添加给 strResult 。
最后将 strResult 显示到结果编辑框 ui->textEdit 里面。

这个示例的代码介绍到这,我们编译运行该示例:
run1
注意看五个元素的位置,多重映射对于 key,这里是 QString 类型的,按照字母顺序排列,区分大小写;
而同 key 的多个 value 排列只和添加顺序有关,不考虑值大小或字母序。
对于同 key 的多个 value,是按照添加顺序反向排列的,早添加的排在后面,晚添加的排在前面。
读者可以查看 Bob 的两个元素,与代码添加顺序是反的。
我们在姓名编辑框输入 abe,电话编辑框输入 10010,点击“添加元素”按钮:
run2
abe 因为是小写的,会排在大写字母姓名的末尾。
我们再把电话编辑框内容改为 56789,点击“删除匹配姓名电话”,可以看到下图结果:
run3
“删除匹配姓名电话”按钮会同时检查姓名和电话,映射中元素的 key-value 必须和编辑框里姓名电话一样才能匹配上,然后才能进行删除。当电话或者姓名有一个不匹配,都不会删除元素,所以上面操作没有找到匹配的元素,无法删除。其他按钮功能读者自行测试。
本节的内容就到这,下一节我们介绍关于哈希映射的内容。


prev
contents
next