Classe de conteneur Qt : Introduction à la classe de conteneur Qt

1. Introduction

La bibliothèque Qt fournit un ensemble de classes de conteneurs génériques basées sur des modèles qui peuvent être utilisées pour stocker des éléments de types spécifiés. Par exemple, si vous avez besoin d'un tableau de QStrings de taille variable, utilisez QVector<QString>.

Ces classes de conteneurs sont conçues pour être plus légères, plus sûres et plus faciles à utiliser que les conteneurs STL (C++ Standard Template Library). Si vous n'êtes pas familier avec la STL, ou si vous préférez utiliser la "méthode Qt", vous pouvez utiliser ces classes au lieu d'utiliser les classes STL.

Vous pouvez parcourir les éléments stockés dans un conteneur de deux manières : les itérateurs de style Java et les itérateurs de style STL. Les itérateurs de style Java sont plus faciles à utiliser et offrent des fonctionnalités plus avancées ; les itérateurs de style STL sont plus efficaces et peuvent être utilisés avec les algorithmes génériques Qt et STL.

Qt fournit également le mot-clé foreach pour nous permettre de parcourir facilement les éléments du conteneur.

2. Conteneurs

Qt fournit des conteneurs séquentiels : QList, QLinkedList, QVector, QStack et QQueue. Étant donné que les données de ces conteneurs sont stockées de manière linéaire les unes après les autres, elles sont appelées conteneurs séquentiels. La plupart du temps, QList est le meilleur choix. Bien qu'il soit implémenté avec un tableau, il est très rapide d'ajouter des éléments au début et à la fin de celui-ci. Utilisez QLinkedList si vous avez besoin d'une liste liée ; utilisez QVector si vous souhaitez que vos éléments soient stockés de manière contiguë en mémoire. QStack et QQueue (pile et file d'attente) fournissent respectivement les mécanismes dernier entré, premier sorti (LIFO) et premier entré, premier sorti (FIFO).

Qt fournit également des conteneurs associatifs : QMap, QMultiMap, QHash, QMultiHash, QSet. Étant donné que ces conteneurs stockent des paires <key, value>, telles que QMap<Key, T>, ils sont appelés conteneurs associatifs. Parmi eux, le conteneur "Multi" prend en charge une clé correspondant à plusieurs valeurs. Le conteneur "Hash" utilise la fonction de hachage pour des recherches rapides sur des ensembles triés, sans recherche binaire.

Le tableau suivant présente les classes de conteneur couramment utilisées.

type	aperçu
QListe<T>	C'est actuellement la classe de conteneur la plus utilisée, qui stocke une chaîne de valeurs d'un type spécifié (T), qui peut être obtenue par indexation. Essentiellement, QList est implémenté avec un tableau, ce qui garantit un accès très rapide basé sur un index.
QListeLiée<T>	Semblable à QList, mais il utilise des itérateurs au lieu d'indices entiers pour obtenir des éléments. Il offre de meilleures performances lors de l'insertion d'éléments au milieu d'une longue liste et dispose d'un meilleur mécanisme d'itération.
QVector<T>	Stocker un ensemble de valeurs dans des emplacements contigus en mémoire, insérer au début ou au milieu est très lent car cela provoque le décalage de nombreux éléments en mémoire d'un emplacement.
QStack<T>	Une sous-classe de QVector qui fournit un mécanisme de dernier entré, premier sorti. Plusieurs méthodes ont été ajoutées au QVector actuel : push(), pos(), top().
QQueue<T>	Une sous-classe de QList, qui fournit un mécanisme premier entré, premier sorti, ajoute plusieurs méthodes à la QList actuelle : enqueue(), dequeue(), head().
QSet<T>	Une collection mathématique de valeurs uniques qui peuvent être recherchées rapidement.
QMap<Clé, T>	Un dictionnaire (tableau associatif) est fourni qui mappe les clés de type Key aux valeurs de type T. Habituellement, une clé correspond à une valeur, QMap stocke les données dans l'ordre des clés, si l'ordre n'est pas important, QHash est un choix plus rapide.
QMultiMap<Clé, T>	Une sous-classe de QMap qui fournit une interface multi-valeurs, une clé correspond à plusieurs valeurs.
QHash<Clé, T>	A presque la même interface que QMap, mais est plus rapide à rechercher. QHash stocke les données sans ordre.
QMultiHash<Clé, T>	Une sous-classe de QHash qui fournit une interface multi-valeurs.

Les avantages de cet article, gratuit pour recevoir le package de matériel d'apprentissage du développement Qt, vidéo technique, y compris (base du langage C++, introduction à la programmation Qt, signal QT et mécanisme de slot, dessin d'image de développement d'interface QT, réseau QT, programmation de base de données QT, QT project combat, QSS, OpenCV, Quick module, interview questions, etc.)

Les conteneurs peuvent également être imbriqués, tels que QMap<QString, QList<int> >, où le type de clé est QString et le type de valeur est QList<int>. Il convient de noter qu'il doit y avoir un espace A, sinon le compilateur traitez-le comme l'opérateur ">>".

Le type de valeur stocké dans divers conteneurs peut être n'importe quel type de données assignable, tel que le type de base double, le type de pointeur, le type de données Qt (tel que QString, QDate, QTime), etc. Cependant, QObject et les sous-classes de QObject ne peuvent pas être stockées dans des conteneurs, mais des pointeurs vers ces classes peuvent être stockés, comme QList<QWidget *>.

3. Exemples de programmes de QList et QMap

Ce qui suit présente les QList et QMap les plus couramment utilisés, et pour les autres conteneurs, vous pouvez vous y référer, car leurs fonctions d'interface sont très similaires, bien sûr, vous pouvez également vous référer au manuel d'aide.

Exemple de programme pour QList

Créez une nouvelle
application console Qt 5 et le nom du projet est
myQList. Ceci est juste pour démontrer l'utilisation de la classe de conteneur QList, donc aucune interface graphique n'est utilisée, vous n'avez donc qu'à créer un programme de console. Modifiez le fichier main.cpp comme suit :

#include <QCoreApplication>
#include <QList>
#include <QDebug>

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    //创建QList列表
    QList<QString> list;

    //插入项目
    list << "aa" << "bb";

    //在列表尾部添加
    list.append("cc");
    //在列表头部添加
    list.prepend("mm");

    //将第一个项目值换为“bc”
    list.replace(0, "ss");

    //第一次遍历输出列表项目值
    qDebug() << "the no.1 list is: ";
    for(int i=0; i<list.size(); ++i)
    {
        qDebug() << list.at(i);   //现在列表为ss aa bb cc
    }
    qDebug() << endl;

    //----------------------------------------------------------
    QString str = list.takeAt(1); //从列表中删除位置1的项目，并获取它
    qDebug() << "at(1) item is: " << str;

    //在位置1插入项目
    list.insert(1, "ab");
    //交换项目1和项目2
    list.swap(1,2);

    //第二次遍历输出列表项目值
    qDebug() << "the no.2 list is: ";
    for(int i=0; i<list.size(); ++i)
    {
        qDebug() << list.at(i);   //现在列表为ss bb ab cc
    }
    qDebug() << endl;

    //-----------------------------------------------------------
    //查询列表中是否包含“ss”
    qDebug() << "contains 'ss' ?" << list.contains("ss");
    //查询列表中包含“mm”的个数
    qDebug() << "the 'ss' count: " << list.count("ss");
    // 第一个“ss”的位置，默认从位置0开始往前查找，返回第一个匹配的项目的位置
    qDebug() << "the first 'ss' index: " << list.indexOf("ss");
    // 第二个“ss”的位置，我们指定从位置1开始往前查找，未找到则返回-1
    qDebug() << "the second 'ss' index: " << list.indexOf("ss", 1);

    return a.exec();
}

Exécutez le programme, la sortie de la fenêtre "Application Output" de Qt est la suivante :

the no.1 list is:
"ss"
"aa"
"bb"
"cc"

at(1) item is:  "aa"
the no.2 list is:
"ss"
"bb"
"ab"
"cc"

contains 'ss' ? true
the 'ss' count:  1
the first 'ss' index:  0
the second 'ss' index:  -1

QList est une classe modèle qui fournit une liste. QList<T> est en fait un tableau de pointeurs vers des éléments de type T, il prend donc en charge l'accès basé sur l'index, et lorsque le nombre d'éléments est inférieur à 1000, il peut implémenter une insertion rapide au milieu de la liste.

QList fournit de nombreuses fonctions d'interface pratiques pour faire fonctionner les éléments de la liste, telles que l'opération d'insertion insert(), l'opération de remplacement replace(), l'opération de suppression removeAt(), l'opération de mouvement move(), l'opération d'échange swap(), à la fin de la table Ajouter un élément append(), ajouter un élément prepend() dans l'en-tête, supprimer un élément de la liste et obtenir l'élément takeAt() et les takeFirst() et takeLast() correspondants, obtenir l'index indexOf() d'un élément , jugez s'il contient l'élément correspondant contains() et obtenez count() du nombre d'occurrences d'un élément, etc.

Pour QList, vous pouvez utiliser l'opérateur "<<'' pour insérer des éléments dans la liste, ou vous pouvez utiliser l'opérateur "[]" pour accéder à un élément via un index, où les éléments sont numérotés à partir de 0. Cependant, pour la lecture- Access uniquement, une autre méthode consiste à utiliser la fonction at(), qui est beaucoup plus rapide que l'opérateur.

Exemple de programme pour QMap

Créez une nouvelle
application console Qt 5 avec le nom de projet
myMap. Ceci est juste pour démontrer l'utilisation de la classe de conteneur QMap, donc aucune interface graphique n'est utilisée, vous n'avez donc qu'à créer un programme de console. Modifiez le fichier main.cpp comme suit :

#include <QCoreApplication>
#include <QMap>
#include <QMultiMap>
#include <QDebug>

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    //创建QMap
    QMap<QString, int> map;
    map["one"] = 1;          //向map中插入("one",1)
    map["three"] = 3;

    //使用insert()函数进行插入
    map.insert("seven", 7);

    //获取键的值，使用“[ ]”操作符时如果map中没有该键，那么会自动插入
    int value1 = map["six"]; //如果map中没有该键，则返回0
    qDebug() << "value1:" << value1;
    qDebug() << "contains 'six' ?" << map.contains("six") << endl;

    //使用value()函数获取键的值，这样当键不存在时不会自动插入
    int value2 = map.value("five");
    qDebug() << "value2:" << value2;
    qDebug() << "contains 'five' ?" << map.contains("five") << endl;

    //当键不存在时，value()默认返回0，这里可以设定该值，比如这里设置为9
    int value3 = map.value("nine", 9);
    qDebug() << "value3:" << value3 << endl;

    //map默认是一个键对应一个值，如果重新给该键设置了值，那么以前的会被擦除
    map.insert("ten", 10);
    map.insert("ten", 100);
    qDebug() << "ten: " << map.value("ten") << endl;

    //可以使用insertMulti()函数来实现一键多值，然后使用values()函数来获取值的列表
    map.insertMulti("two", 2);
    map.insertMulti("two", 4);
    QList<int> values = map.values("two");
    qDebug() << "two: " << values << endl;

    //------------------------------------------------------------------

    //也可以使用QMultiMap类来实现一键多值
    QMultiMap<QString, int> map1, map2, map3;
    map1.insert("values", 1);
    map1.insert("values", 2);
    map2.insert("values", 3);
    //可以进行相加，这样map3的“values”键将包含2,1,3三个值
    map3 = map2 + map1;
    QList<int> myValues = map3.values("values");
    qDebug() << "the values are: ";
    for (int i=0; i<myValues.size(); ++i)
    {
        qDebug() << myValues.at(i);
    }

    return a.exec();
}

Exécutez le programme, la sortie de la fenêtre "Application Output" de Qt est la suivante :

value1: 0
contains 'six' ? true

value2: 0
contains 'five' ? false

value3: 9

ten:  100

two:  (4, 2)

the values are:
2
1
3

La classe QMap est une classe de conteneur qui fournit un dictionnaire basé sur une liste de sauts. QMap<Key,T> est l'une des classes de conteneurs génériques de Qt, qui stocke des paires (clé, valeur) et fournit une recherche rapide de la valeur associée à la clé.

QMap fournit de nombreuses fonctions d'interface pratiques, telles que l'opération d'insertion inSert(), get value value(), s'il faut inclure une clé contains(), supprimer une clé remove(), supprimer une clé et obtenir la valeur correspondant à la clé take ( ), insérer une clé multi-valeur insertMulti(), etc.

Vous pouvez utiliser l'opérateur "[]" pour insérer une paire clé-valeur ou obtenir la valeur d'une clé, mais lorsque vous utilisez cet opérateur pour obtenir la valeur d'une clé qui n'existe pas, la clé sera insérée dans la carte par default ; afin d'éviter cette situation, vous pouvez utiliser la fonction value() pour obtenir la valeur de la clé. Lors de l'utilisation de la fonction value(), si la clé spécifiée n'existe pas, elle renverra par défaut 0. Vous pouvez fournir des paramètres lors de l'utilisation de cette fonction pour modifier la valeur renvoyée par défaut. QMap utilise par défaut une clé correspondant à une valeur, mais vous pouvez également utiliser insertMulti() pour insérer une clé et plusieurs valeurs. Dans le cas d'une clé et de plusieurs valeurs, il est plus pratique d'utiliser QMultiMap, une sous-classe de QMap.

L'article est transféré du jardin du blog (fengMisaka) : Une des classes de conteneur Qt : Introduction aux classes de conteneur Qt - fengMisaka - 博客园

Les avantages de cet article, gratuit pour recevoir le package de matériel d'apprentissage du développement Qt, vidéo technique, y compris (base du langage C++, introduction à la programmation Qt, signal QT et mécanisme de slot, dessin d'image de développement d'interface QT, réseau QT, programmation de base de données QT, QT project combat, QSS, OpenCV, Quick module, interview questions, etc.)