【Qt】Qt中关联容器QMap，QMultiMap，QHash，QMultiHash 的理解

在Qt中，有几种关联容器可供选择：

1. QMap：QMap是一个关联容器，存储键-值对，并根据键自动进行排序。它提供了快速的查找和插入操作，适用于需要根据键进行排序和搜索的场景。

2. QMultiMap：QMultiMap是一个关联容器，类似于QMap，但允许有重复的键。它还保了插入元素的顺序，可通过迭代器进行遍历。

3. QHash：QHash是一个关联容器，根据键的哈希值进行快速查找和插入操作。它不会对键进行排序，适用于需要快速查找的场景。

4. QMultiHash：QMultiHash是一个关联容器，类似于QHash，但允许有重复的键。它还保留了插入元素的顺序，可以通过迭代器进行遍历。

这些关联容器在Qt中提供了灵活而强大的数据结构选项，根据具体的需求和使用场景，您可以选择适合的容器来存储和管理数据。需要注意的是，这些容器都是基于Qt的容器类提供的，并且为了方便使用，它们也提供了类似STL容器的接口和使用方式。

1.QMap：QMap 是一个有序的关联容器，它根据键的排序来存储键-值对。示例用法如下：

#include 
#include 

int main() {
    QMap<int, QString> map;
    
    // 插入键值对
    map.insert(1, "Apple");
    map.insert(2, "Banana");
    map.insert(3, "Orange");
    
    // 通过键查找值
    qDebug() << map.value(2);
    
    // 遍历所有键值对
    for(auto it = map.begin(); it != map.end(); ++it) {
        qDebug() << "Key:" << it.key() << "Value:" << it.value();
    }
    
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

2.QHash：QHash 是一个无序的关联容器，通过哈希函数来查找键-值对。示例用法如下：

#include 
#include 

int main() {
QHash<QString, int> hash;

// 插入键值对
hash.insert("Apple", 10);
hash.insert("Banana", 20);
hash.insert("Orange", 30);

// 通过键查找值
qDebug() << hash.value("Banana");

// 遍历所有键值对
QHash<QString, int>::iterator it;
for(it = hash.begin(); it != hash.end(); ++it) {
    qDebug() << "Key:" << it.key() << "Value:" << it.value();
}

return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

3.QMultiMap：QMultiMap 是一个允许有重复键的有序关联容器。示例用法如下：

#include 
#include 
#include 

int main()
{
    QMultiMap<int, QString> multimap;

    // 插入键值对
    multimap.insert(1, "apple");
    multimap.insert(2, "banana");
    multimap.insert(1, "orange");
    multimap.insert(3, "grape");

    // 使用迭代器遍历multimap
    qDebug() << "Multimap elements:";
    for (auto it = multimap.begin(); it != multimap.end(); ++it) {
        qDebug() << it.key() << "->" << it.value();
    }

    // 使用equal_range函数查找与键关联的元素范围
    auto range = multimap.equal_range(1);
    qDebug() << "Elements with key 1:";
    for (auto it = range.first; it != range.second; ++it) {
        qDebug() << it.key() << "->" << it.value();
    }

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

输出为：

Multimap elements:
1 -> "apple1 -> "orange"
2 -> "banana"
3 -> "grape"
Elements with key 1:
1 -> "apple"
1 -> "orange"
1
2
3
4
5
6
7

在上述示例中，我们使用QMultiMap类创建了一个multimap对象，并通过insert函数插入了一些键值对。然后，我们使用迭代器循环遍历整个multimap，并使用equal_range函数查找与键关联的元素范围。

（出错）注释：使用foreach时候，注意打印的时候，打印hash.values(key)，要使用values。
否则就会出错，如果使用的是value，那么会打印两次相同的值，出现了类似覆盖，实际上是取出的key，hash会映射出它认为要映射出的值。

这里还需要注意一个地方：它内部的存储结构到底是怎样的？下面的图解释的清晰：

可以看出multihash中存储key的地址都是不一样的。说明一个新的映射，就会有新的地址。

4.以下是一个使用QMultiHash的示例用法：

#include 
#include 

int main() {
    QMultiHash<int, QString> multiHash;
    
    // 向多重哈希表插入键-值对
    multiHash.insert(1, "Apple");
    multiHash.insert(2, "Banana");
    multiHash.insert(1, "Orange");
    multiHash.insert(3, "Grape");
    
    // 遍历所有键值对
    for(auto it = multiHash.begin(); it != multiHash.end(); ++it) {
        qDebug() << "Key:" << it.key() << "Value:" << it.value();
    }
    
    // 查找特定键的值
    int key = 1;
    QList<QString> values = multiHash.values(key);
    qDebug() << "Values for key" << key << ":" << values;
    
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

在上述示例中，我们创建了一个QMultiHash对象，并使用insert函数向哈希表中插入了多个键-值对。注意，由于QMultiHash允许存在重复的键，因此可以插入多个具有相同键的值。然后，我们使用迭代器遍历了整个多重哈希表，并打印出每个键值对。

接着，我们演示了如何使用values函数来查找特定键的所有值，并将它们存储在一个QList中。

那么有一个问题，QMultiHash和QMultiMap到底有哪些区别?

QMultiHash和QMultiMap是Qt提供的两种关联容器，它们都允许键的重复，但在实现和使用上有一些区别：

1. 数据结构：QMultiHash使用哈希表作为其底层数据结构，而QMultiMap使用有序的红黑树。由于哈希表的特性，QMultiHash在插入和查找操作上通常比QMultiMap更快，因为它使用哈希函数进行数据存储和问。而QMultiMap能够保持数据的有序性，适合需要保持插入顺序的场景。

2. 迭代器顺序：QMultiHash迭代器的顺序是不确定的，而QMultiMap的迭代器是根据键的排序顺序进行遍历的，因为QMultiMap使用红黑树实现了基于排序的容器。

3. 接口差异：尽管两者提供了类似的接口，包括插入、查找、删除等功能，但在一些特定操作上有所不同，比如QMultiHash的values函数返回一个列表，但对于QMap，您可以使用find函数查找特定键的范围。

根据需求，您可以选择QMultiHash或QMultiMap来适应不同的场景。如果需要快速的插入和查找操作，并且键的顺序并不重要，QMultiHash是更好的选择。而如果需要保持有序并且对键的顺序有要求，QMultiMap更适合。