精华内容
下载资源
问答
  • Qt容器类

    2013-08-23 16:26:35
    主要讲解Qt容器类,附有代码注释讲解。很清楚。
  • Qt提供了多个基于模板的容器类,这些容器类可以用于存储指定类型的数据项,例如常用的字符串列表类 QStringList 就是从容器类 QLiSt<QString> 继承的,实现对字符串列表的添加、存储、删除等操作。Qt 的容器...

     

    Qt 提供了多个基于模板的容器类,这些容器类可以用于存储指定类型的数据项,例如常用的字符串列表类 QStringList 就是从容器类 QLiSt<QString> 继承的,实现对字符串列表的添加、存储、删除等操作。

    Qt 的容器类比标准模板库(STL)中的容器类更轻巧、安全和易于使用。这些容器类是隐式共享和可重入的,而且它们进行了速度和存储优化,因此可以减少可执行文件的大小。此外,它们还是线程安全的,也就是说它们作为只读容器时可被多个线程访问。

    容器类是基于模板的类,如常用的容器类 QList<T>,T 是一个具体的类型,可以是 int、float 等简单类型,也可以是 Qstring、QDate 等类,但不能是 QObject 或任何其子类T 必须是一个可赋值的类型,即T必须提供一个缺省的构造函数,一个可复制构造函数和一个赋值运算符。

    例如用 QList<T> 定义一个字符串列表的容器,其定义方法是:

    QList<QString> aList;

    这样定义了一个 QList 容器类的变量 aList,它的数据项是 QString,所以 aList 可以用于处理字符串列表,例如:

    aList.append("Monday");
    aList.append("Tuesday");
    aList.append("Wednesday");
    QString str=aList[0];

    Qt 的容器类分为顺序容器关联容器

     

    顺序容器类

    Qt 的顺序容器类有 QList、QLinkedList、QVector、QStack 和 QQueue。

    QList

    QList 是最常用的容器类,虽然它是以数组列表的形式实现的,但是在其前或后添加数据非常快,QList 以下标索引的方式对数据项进行访问。

    QList 用于添加、插入、替换、移动、删除数据项的函数有:insert()、replace()、removeAt()、move()、swap()、append()、prepend()、removeFirst() 和 removeLast() 等。

    QList 提供下标索引方式访问数据项,如同数组一样,也提供 at() 函数,例如:

    QList<QString> list;
    list << "one" << "two" << "three";
    QString str1=list[1]; //str1=="two"
    QString str0=list.at(0); //str0=="one"

    QList 的 isEmpty() 函数在数据项为空时返回 true,size() 函数返回数据项的个数。

    QList 是 Qt 中最常用的容器类,很多函数的参数传递都是采用 QList 容器类,例如 QAudioDeviceInfo 的静态函数 availableDevices() 的函数原型是:

    QList<QAudioDeviceInfo> QAudioDeviceInfo::availableDevices(QAudio::Mode mode)

    其返回数据就是 QAudioDeviceInfo 类型的 QList 列表。

    QLinkedList

    QLinkedList<T> 是链式列表,数据项不是用连续的内存存储的,它基于迭代器访问数据项,并且插入和删除数据项的操作时间相同。

    除了不提供基于下标索引的数据项访问外,QLinkedList 的其他接口函数与 QList 基本相同。

    QVector

    QVector<T> 提供动态数组的功能,以下标索引访问数据。

    QVector 的函数接口与 QList 几乎完全相同,QVector<T> 的性能比 QList<T> 更高,因为 QVector<P> 的数据项是连续存储的。

    QStack

    QStack<T> 是提供类似于堆栈的后入先出(LIFO)操作的容器类,push() 和 pop() 是主要的接口函数。例如:

    QStack<int> stack;
    stack.push(10);
    stack.push(20);
    stack.push(30);
    while (!stack.isEmpty())
    cout << stack.pop() << endl;

     

    程序会依次输出 30, 20, 10。

    QQueue

    QQueue<T> 是提供类似于队列先入先出(FIFO)操作的容器类。enqueue() 和 dequeue() 是主要操作函数。例如:

    QQueue<int> queue;
    queue.enqueue (10);
    queue.enqueue(20);
    queue.enqueue (30);
    while (!queue.isEmpty())
    cout << queue.dequeue() << endl;

     程序会依次输出 10, 20,30。

    关联容器类

    Qt 还提供关联容器类 QMap、QMultiMap、QHash、QMultiHash 和 QSet

    QMultiMap 和 QMultiHash 支持一个键关联多个值,QHash 和 QMultiHash 类使用散列函数进行查找,查找速度更快。

    QSet

    QSet 是基于散列表的集合模板类,它存储数据的顺序是不定的,查找值的速度非常快。 QSet<T> 内部就是用 QHash 实现的。

    定义 QSet<T> 容器和输入数据的实例代码如下:

    QSet<QString> set;
    set << "dog" << "cat" << "tiger";

    测试一个值是否包含于这个集合,用 contains() 函数,示例如下:

    if (!set.contains("cat"))
        ...

    QMap

    QMap<Key, T> 提供一个字典(关联数组),一个键映射到一个值。QMap 存储数据是按照键的顺序,如果不在乎存储顺序,使用 QHash 会更快。

    定义 QMap<QString,int> 类型变量和赋值的示例代码如下:

    QMap<QString, int> map;
    map["one"] = 1;
    map["two"] = 2;
    map["three "] = 3;

    也可以使用 insert() 函数赋值,或 remove() 移除一个键值对,示例如下:

    map.insert("four", 4);
    map.remove("two");

    要查找一个值,使用运算符“[]”或 value() 函数,示例如下:

    int num1 = map["one"];
    int num2 = map.value("two");

    如果在映射表中没有找到指定的键,会返回一个缺省构造值,例如,如果值的类型是字符串,会返回一个空的字符串。

    在使用 value() 函数查找键值时,还可以指定一个缺省的返回值,示例如下:

    timeout = map.value("TIMEOUT",30);

    这表示如果在 map 里找到键“TIMEOUT”,就返回关联的值,否则返回值为 30。

    QMultiMap

    QMultiMap 是 QMap 的子类,是用于处理多值映射的便利类。

    多值映射就是一个键可以对应多个值。QMap 正常情况下不允许多值映射,除非使用 QMap::insertMulti() 添加键值对。

    QMultiMap 是 QMap 的子类,所以 QMap 的大多数函数在 QMultiMap 都是可用的,但是有几个特殊的,QMultiMap::insert() 等效于 QMap::insertMulti() , QMultiMap::replace() 等效于 QMap::insert()。

    QMultiMap 使用示例如下:

    QMultiMap<QString, int> map1, map2, map3;
    map1.insert("plenty", 100);
    mapl.insert("plenty", 2000); // map1.size() == 2
    map2.insert("plenty", 5000); // map2.size() == 1
    map3 = map1 + map2; // map3.size() == 3

    QMultiMap 不提供“[]”操作符,使用 value() 函数访问最新插入的键的单个值。如果要获取一个键对应的所有值,使用 values() 函数,返回值是 QList<T> 类型。

    QList<int> values = map.values("plenty");
    for (int i = 0; i < values.size(); ++i)
        cout << values.at(i) << endl;

    QHash

    QHash 是基于散列表来实现字典功能的模板类,QHash<Key,T> 存储的键值对具有非常快的查找速度。

    QHash 与 QMap 的功能和用法相似,区别在于以下几点:

    1. QHash 比 QMap 的查找速度快;
    2. 在 QMap 上遍历时,数据项是按照键排序的,而 QHash 的数据项是任意顺序的;
    3. QMap 的键必须提供“<”运算符,QHash 的键必须提供“==”运算符和一个名称为 qHash() 的全局散列函数。

    QMultiHash

    QMultiHash 是 QHash 的子类,是用于处理多值映射的便利类,其用法与 QMultiMap 类似。

     

    展开全文
  • 学习QT容器类

    2020-03-01 11:20:40
    学习QT之容器类 Qt提供了一组通用的基于模板的容器类。...存储在Qt容器中的数据必须是可赋值的数据类型,也就是说,这种数据类型必须提供一个默认的构造函数、一个复制构造函数和一个赋值操作运算符。 这样的数...

    学习QT之容器类


    Qt提供了一组通用的基于模板的容器类。对比C++的标准模板库中的容器类,Qt的这些容器更轻量、更安全并且更容易使用。此外,Qt的容器类在速度、内存消耗和内联(inline)代码等方面进行了优化(较少的内联代码将说件可执行程序的大小)。

    存储在Qt容器中的数据必须是可赋值的数据类型,也就是说,这种数据类型必须提供一个默认的构造函数、一个复制构造函数和一个赋值操作运算符。

    这样的数据类型包含了通常使用的大多数数据类型,包括基本数据类型(如int和double等)和Qt的一些数据类型(如QString、QDate和QTime等)。不过,Qt的QObject及其他的子类(如QWidget和QDialog等)是不能存储在容器中的,例如:QList list;,一个可代替的方案是存储QObject及其子类的指针,例如:QList<QToolBar *> list。容器也可以嵌套使用,例如:QHash<QString,QList >; 注意容器类嵌套时后面的>之间一定要加一个空格,否则,C++编译器会将两个>符号解释为>>,导致无法通过编译器编译。

    一、QList类、QLinkedList类和QVector类

    1、QList类

    QList是迄今为止最常用的容器类,它存储给定数据类型T的一列数值。继承自QList类的子类有QItemSelection、QQueue、QSigbalSpy、QStringList和QTestEventList。

    函数功能
    append()在尾部追加数据
    prepend()在头部追加数据
    insert(pos, value)在pos位置处插入value
    #include<QDebug>
    int main()
    {
        QList<QString> list;  //初始化一个QList<QString>对象list
        {
            QString str("This is a string");
            list<<str;  //将字符串str加入list中
        }
        qDebug()<<list[0]<<"How are you! ";
        
        return 0;
    }
    
    2、QLinkedList类

    QLinkedList是一个链式列表,它以非连续的内存块保存数据。

    QLinkedList不能使用下标,只能使用迭代器访问它的数据项。与QList相比,当对一个很大的列表进行插入操作时,QLinkedList具有更高的效率。

    3、QVector类

    QVector在相邻的内存中存储给定数据类型T的一组数值。在一个QVector的前部或者中间位置进行插入操作的速度是很慢的,这因为这样的操作将导致内存中的大量数据被移动,这是由QVector存储数据的方式决定的。

    QVector既可以使用下标访问数据项,也可以使用迭代器访问数据项。继承自QVector类的子类有QPolygon、QPolygonF和QStack。

    4、java风格迭代器遍历容器

    Java风格迭代器同STL风格迭代器相比,使用起来更简单方便,不过这也是以轻微的性能损耗为代价的。对于每一个容器类,Qt提供了两种类的Java风格迭代器数据类型,即只读迭代器类和读写迭代器类。

    容器类只读迭代器类读写迭代器类
    QList,QQueueQListIteratorQMutableListIterator
    QLinkedListQLinkedListIteratorQMutableLinkedListIterator
    QVector,QStackQVectorIteratorQMutableVectorIterator

    Java风格迭代器的迭代的位于列表项的中间,而不是直接指向某个列表项。因此,它的迭代点或者在第一个列表项的前面,或者在两个列表项之间,或者在最后一个列表项之后。

    (1)、QList只读迭代器遍历

    方法功能
    hasNext()检查当前迭代点之后是否有列表项
    hasPrevious()检查当前迭代点之前是否有列表项
    toBack()将迭代点移到最后一个列表项的后面
    toFront()将迭代点移动列表的最前端
    next()跳过下一个列表项,并返回它跳过的列表项的内容
    peekNext()返回下一个列表项,但不移动迭代点
    peekPrevious()返回前一个列表项,但不移动迭代点
    findNext()从当前迭代点开始向后查找指定的列表项,如果找到,则返回true,此时迭代点位于匹配列表项的后面;如果没有找到,则返回false,此时迭代点位于列表项的后端(最后一个列表项的后面)
    findPrevious()与findNext()类似,不同的是,它的方向是向前的,查找操作完成后的迭代点在匹配项的前面或整个列表的前端

    实例代码

    #include<QCoreApplication>
    #include<QDebug>
    int main(int argc,char *argv[])
    {
        QCoreApplication a(argc,argv);
        QList<int> list;                        //创建一个空的列表list
        QListIterator<int> iter(list);          //创建一个上述列表的只读迭代器
        list<<1<<2<<3<<4;
        for(;iter.hasNext();)
        	qDebug()<<iter.next();
    
        return a.exec();
    }
    

    (2)、QList读写迭代器遍历

    读写迭代器除了上述基本的遍历操作外,还提供了如下函数:

    方法功能
    insert(value)在列表中插入值value
    remove()在列表中移除数据
    setValue(value)在列表中设置数据

    实例代码

    #include<QCoreApplication>
    #include<QDebug>
    int main(int argc,char *argv[])
    {
        QCoreApplication a(argc,argv);
        QList<int> list;                        //创建一个空的列表list
        QMutableListIterator<int> iter(list);          //创建一个上述列表的只读迭代器
        for(int i=0;i<10;i++)
    		iter.insert(i);
        for(i.toFront;i.hasNext();)
    		qDebug()<<iter.next();
        for(iter.toBack();iter.hasPrevious;)
        {
            if(iter.previous()%2==0)
                iter.remove();
            else
                iter.setValue(iter.peekNext()*10);
        }
        for(iter.toFront();iter.hasNext();)
    		qDebug()<<iter.next();
        
        return a.exec();
    }
    
    5、STL风格迭代器遍历容器

    对于每个容器类,Qt都提供了两种类型的STL风格迭代器数据类型:一种提供只读访问;另一种提供读写访问。由于只读类型的迭代器的运行速度要比读写迭代器的运行速度快,所以应尽可能地使用只读类型的迭代器。

    STL风格迭代器的API是建立在指针操作基础上的。例如,“++”操作运算符移动迭代器到下一个项(item),而"*"操作运算符返回迭代器指向的项。

    不同于Java风格迭代器,STL风格迭代器的迭代点直接指向列表项

    容器类只读迭代器读写迭代器
    QList,QQueueQList::const_iteratorQList::iterator
    QLinkedListQLinkedList::const_iteratorQLinkedList::iterator
    QVector,QStackQVector::const_iteratorQVector::iterator
    #include<QCoreApplication>
    #include<QDebug>
    int main(int argc,char *argv[])
    {
        QCoreApplication a(argc,argv);
        QList<int> list;
        QList<int>::iterator iter;  //创建一个读写迭代器
        for(int i=0;i<10;i++)
            list.insert(list.end(),i);
        for(iter=list.begin();iter!=list.end();++iter)
        {
            qDebug()<<*iter;
            *iter=(*iter)*10;
        }
        
        QList<int>::const_iterator c_iter;  //创建一个只读迭代器
        for(c_iter=list.constBegin();c_iter!=list.constEnd();++c_iter)
            qDebug()<<*c_iter;
        
        return a.exec();
    }
    

    QLinkedList和QVector具有和QList相同的遍历接口,在此就不再详细讲解了。

    二、QMap类和QHash类

    QMap类和QHash类具有非常类似的功能,它们的差别仅在于:

    1. QHash具有比QMap更快的查找速度;
    2. QHash以任意的顺序存储数据项,而QMap总是按照键key的顺序存储数据;
    3. QHash的键类型key必须提供operator==()和一个全局的qHash(Key)函数,而QMap的键类型Key必须提供opeator<()函数。
    1、QMap类

    QMap<Key,Value>提供了一个从类型为Key的键到类型为T的值的映射。通常QMap存储的数据形式是一个键对应一个值,并且按照键Key的顺序存储数据。为了能够支持一键多值的情况,QMap提供了QMap<Key,Value>::insertMulti()和QMap<Key,Value>::values()函数。存储一键多值的数据时,也可以使用QMultiMap<Key,Value>容器,它继承自QMap。

    2、QHash类

    QHash<Key,Value>具有和QMap几乎完全相同的API。QHash维护着一张哈希表,哈希表的大小与QHash的数据项的数目相适应。

    QHash以任意顺序组织它的数据。当存储数据的顺序无关紧要是,建议使用QHash作为存放数据的容器。QHash也可以存储一键多值形式的数据,它的子类QMultiHash<Key,Value>实现了一键多值的语言。

    3、Java风格迭代器遍历

    对于每一个容器,Qt都提供了两种类型的Java风格迭代器数据类型:一种提供只读访问;另一种提供读写访问。

    容器类只读迭代器类读写迭代器类
    QMap<Key,Value>,QMultiMap<Key,Value>QMapIterator<Key,Value>QMutableMapIterator<Key,Value>
    QHash<Key,Value>,QMultiHash<Key,Value>QHashIterator<Key,Value>QMutableHashIterator<Key,Value>

    (1)、QMap只读迭代器遍历

    方法功能
    hasNext()检查是否有下一个列表项
    next()跳过下一个列表项,并访问该列表项
    key()访问键
    value()访问值
    findValue(value)寻找值
    setValue(value)设置值
    insert(Key,Value)插入键值对
    #Include<QCoreApplication>
    #Include<QDebug>
    int main(int argc,char *argv)
    {
        QCoreApplication a(argc,argv);
        QMap<QString,QString> map;
        map.insert("BeiJin","111");
        map.insert("ShangHai","021");
        map.insert("NanJin","025");
        QMapIterator<QString,QString> const_iter(map);
        for(;const_iter.hasNext();)
        {
            const_iter.next;
            qDebug()<<" "<<const_iter.key()<<" "<<const_iter.value();
        }
        QMutableMapIterator<QString,QString> iter(map);
        if(iter.findNext("111"))
            iter.setValue("101");
        for(;iter.hasNext();)
        {
            iter.next();
            qDebug()<<" "<<iter.key()<<" "iter.value();
        }
        
        return a.exec();
    }
    

    运行结果如下:

    "BeiJin"    "111"
    "NanJin"    "025"
    "ShangHai"  "021"
    "BeiJin"    "101"
    "NanJin"    "025"
    "ShangHai"  "021" 
    
    4、STL风格迭代器遍历

    对于每一个容器类,Qt都提供了两种类型的STL风格迭代器数据类型:一种提供只读访问;另一种提供读写访问。

    容器类只读迭代器类读写迭代器类
    QMap<Key,Value>,QMultiMap<Key,Value>QMap<Key,Value>::const_iteratorQMap<Key,Value>::iterator
    QHash<Key,Value>,QMultiHash<Key,Value>QHash<Key,Value>::const_iteratorQHash<Key,Value>::iterator
    #include<QCoreApplication>
    #Include<QDebug>
    int main(int argc,char *argv)
    {
        QCoreApplication a(argc,argv);
        QMap<QString,QString> map;
        map.insert("BeiJin","111");
        map.insert("ShangHai","021");
        map.insert("NanJin","025");
        QMap<QString,QString>::const_iterator const_iter;
        for(const_iter=map.constBegin();const_iter!=map.constEnd();++const_iter)
            qDebug()<<" "<<const_iter.key()<<" "<<const_iter.value();
        QMap<QString,QString>::iterator iter;
        iter=map.find("BeiJin");
        if(iter!=map.end())
            iter.value()="010";
        QMap<QString,QString>::const_iterator modi;
        for(modi=map.constBegin();modi!=map.constEnd();++modi)
            qDebug()<<" "<<modi.key()<<" "modi.value();
        
        return a.exec();
    }
    

    运行结果如下:

    "BeiJin"    "111"
    "NanJin"    "025"
    "ShangHai"  "021"
    "BeiJin"    "101"
    "NanJin"    "025"
    "ShangHai"  "021" 
    

    三、QVariant类

    QVariant类类似于C++的联合(union)数据类型,它不仅能保存很多Qt类型的值,包括QCore、QBrush、QFont、QPen、QString和QSize等,而且也能存放Qt的容器类型的值。Qt的很多功能都是建立在QVariant基础上的,如Qt的对象属性即数据库功能等。

    #include"widget.h"
    #include<QDebug>
    #include<QVariant>
    #include<QColor>
    Widget::Wideget(QWidget *parent)
        : QWidget(parent)
    {
        QVariant v(709);         //声明一个QVariant变量,并初始化为一个整数
        qDebug()<<v.toInt();
        QVariant w("How are you! ");     //声明一个QVariant变量,并初始化为一个字符串
        qDebug()<<w.toString;
        QMap<QString,QVariant> map;
        map["int"]=709;
        map["double"]=709.709;
        map["string"]="How are you! ";
        map["color"]=QColor(255,0,0);
        qDebug()<<map["int"]<<map["int"].toInt();
        qDebug()<<map["double"]<<map["double"].toDouble();
        qDebug()<<map["string"]<<map["string"].toString();
        qDebug()<<map["color"]<<map["color"].value<QColor>();
            
        QStringList s1;
        s1<<"A"<<"B"<<"C"<<"D";
        QVariant slv(s1);
        if(slv.type==QVariant.toStringList)
        {
            QStringList list=slv.toStringList();
            for(int i=0;i<list.size();++i)
                qDebug()<<list.at(i);
        }
    }
    

    说明:QVariant::type()函数返回存储在QVariant变量中的值的数据类型。QVariant::StringList是Qt定义的一个QVariant::type枚举类型的变量。Qt的常用QVariant::type枚举类型变量如下:

    变量对应的类型变量对应的类型
    QVariant::Invaild无效类型QVariant::TimeQTime
    QVariant::RegionQRegionQVariant::LineQLine
    QVariant::BitmapQBitmapQVariant::PaletteQPalette
    QVariant::BoolboolQVariant::ListQList
    QVariant::BrushQBrushQVariant::SizePolicyQSizePolicy
    QVariant::SizeQSizeQVariant::StringQString
    QVariant::CharQCharQVariant::MapQMap
    QVariant::ColorQColorQVariant::StringListQStringList
    QVariant::CursorQCursorQVariant::PointQPoint
    QVariant::DateQDateQVariant::PenQPen
    QVariant::DateTimeQDateTimeQVariant::PixmapQPixmap
    QVariant::DoubledoubleQVariant::RectQRect
    QVariant::FontQFontQVariant::ImageQInage
    QVariant::IconQIconQVariant::UserType用户自定义类型

    运行结果如下:

    709
    "How are you! "
    QVariant(int 709) 709
    QVariant(double,709.709) 709.709
    QVariant(QString,"How are you! ") "How are you! "
    QVariant(QColor,QColor(ARGB 1,1,0,0)) QColor(ARGB 1,1,0,0)
    "A"
    "B"
    "C"
    "D"
    
    展开全文
  • Qt常用容器类归纳

    2018-06-24 23:28:58
    Qt容器类的两种风格迭代器:① Java-style iterators② STL- style iterators因为QList、QLinkedList、QVector、QStack和QQueue等容器中数据都是一个接一个线性存储的,故称为顺序容器。对大部分应用程序来说,QList...

    一、容器类介绍

    Qt提供了许多基于模板的容器类。这些类可以被用来存储特定类型的项。

    Qt容器类的两种风格迭代器:

    ① Java-style iterators

    ② STL- style iterators

    因为QList、QLinkedList、QVector、QStack和QQueue等容器中数据都是一个接一个线性存储的,故称为顺序容器。对大部分应用程序来说,QList都是一个很好的选择。尽管它在底层被实现为一个array-list(数组列表),但它为我们提供了非常快速的添加操作,可以在其头部和尾部进行添加操作。若需确保元素占用连续的内存空间,可以使用QVector。QStack和QQueue是两个提供了LIFO(后进先出)和FIFO(先进先出)语义的类。

    因为QMap、QMultiMap、QHash、QMultiHash和QSet等容器存储的是<键,值>对,比如QMap<Key,T>,所以称为关联容器。"Multi"容器又支持一个key可以关联多个value。"Hash"容器通过使用一个hash函数而不是二分搜索提供了更快速的查找操作。

    这些容器类有以下特点:

    1.隐式共享的;

    2.可重入的;

    3.在速度上进行了优化;

    4.内存占用少,内联代码扩展少,从而可以产生更小的可执行文件;

    5.当他们被用作只读容器时,仍可以认为是线程安全的。

    容器是可以嵌套使用的。例如,可以使用QMap<QString,QList<int>>这种类型,其key的类型是QString,值类型是QList<int>。

    将这些容器类的总结在下表中:

    QList<T> 这是目前最通用的容器类。它存储了给定类型T的值一个列表,这些值可以通过索引(下标)访问。其实,在内部QList被实现为一个数组,确保快速的基于索引(下标)的访问。可以使用QList::append()和QList::prepend()向链表的两端添加元素,或者使用QList::insert()在链表的中间插入元素。并且,和其他容器相比,更重要的是,QList在可执行文件中展开的代码量是非常少的,是经过高度优化的。常用的QStringList继承自QList<QString>。
    QLinkedList<T> 这个容器类类似于QList,只不过它是使用迭代器来访问,而不是下标。当从中间插入时,它的效率比QList还要高。并且,它有更好的迭代器语义。
    即指向QLinkedList中某个元素的迭代器,只有该元素存在就会一直保持有效,而指向QList中某元素的迭代器,在向QList进行任意插入或删除时都会导致该迭代器失效。
    QVector<T>这个容器类会在一块相邻的内存中存储一个给定类型的值的数组。在一个vector的前端或中间插入是非常慢的,因为这会导致大量现存的元素移动以为新的
    元素腾出位置。
    QStack<T>继承自QVector,是其便捷子类,提供了后进先出(LIFO)的语义。添加了push()、pop()及top()等函数。
    QQueue<T>继承自QList,是其便捷子类,提供了先入先出(FIFO)的语义。添加了enqueue()、dequeue()和head()等函数
    QSet<T>

    这个容器类提供了不允许有重复值的集合,提供可以快速查询单值的数字集。

    QMap<Key, T>这个容器类提供了一个字典形式(关联数组)的容器,它会将Key类型的值映射到T类型的value上。通常情况下,每一个key只关联一个值。并且,QMap会按Key的顺序来存储相应的值;所以,如果不关心元素的存储顺序,QHash是一个更好的选择,因为QHash速度更快。
    QMaultiMap<Key, T>继承自QMap,是其便捷子类,提供了实现多值映射的接口函数,也就是说,该容器中的一个key可以关联多个值。
    QHash<Key, T>该容器类拥有与QMap几乎一样的接口,但它提供了更快速的查找操作。并且,该类会按任意的顺序存储值。
    QMultiHash<Key, T>继承自QHash,是其便捷子类,提供了实现多值散列的接口函数。

    二、通用算法

    Qt还提供了在任意容器上执行相关操作的通用算法。

    qSort()算法对一个连续容器进行排序,qBinaryFind()在经过排序的连续容器上执行一个二进制搜索。

    qTtableSort()算法与qSort()很相似,但qStableSort()算法还可以保证进行对等比较的项在排序之后表现与之前相同的排序。

    <QtAlgorithmn>的头文件声明了在容器类上实现基本算法的一套全局模板函数。这些函数中的大部分都是在STL风格上的迭代器上工作的。

    qFind()算法在容器中查找一个特定的值。它接受一个“begin”和一个“end”迭代器,并且返回一个与其匹配的指向第一项的迭代器;如果没有匹配的项,则返回“end”

    qBinaryFind()算法执行的搜索操作与qFind类似,其区别在于qBinaryFind()算法假设项都是以升序的顺序存储的,并且使用了快速二分搜索而不是qFind()算法的线性搜索。

    qFill()算法采用了一个特定的值初始化一个容器

    qCopy()算法将一个容器类的值复制到另一个容器类中

    qDeleteAll()算法对每一个存储在容器类中的指针调用delete。这仅对于那些为指针类型的容器类才有意义的,在调用之后,这些项仍然作为悬摆指针存在于容器类中上

    qSwap()算法可以交换两个变量的值。

    返回参数绝对值的qAbs()函数,返回最大、最小值的qMax()、qMin()函数。


    展开全文
  • Qt容器类

    2016-09-12 14:43:01
    一、容器类的时间复杂度比较 二、QList类 #include int main(int argc ,char *argv[]) { QList str; { QString string("welcome to my world\n"); str;//向容器写入字符 } qDebug()[0

    一、容器类的时间复杂度比较


    二、QList类

    #include<QDebug>
    int main(int argc ,char *argv[])
    {  
       QList<QString> str;
        {
            QString string("welcome to my world\n");
            str<<string;//向容器写入字符
    
        }
        qDebug()<<str[0]<<"how are you!";
        return 0;
    }


    展开全文
  • QT容器类

    2019-11-23 21:14:21
    QT容器类,相对于C++的STL容器类,更为小巧、安全和方便使用。QT5在容器类里面做了优化速度、内存、inline等操作。 QT5容器类:QList、QLinkedList、QVector、QMap、QHash、QVariant类等。 QT5容器类中,容器可以...
  • Qt 提供了多个基于模板的容器类,这些容器类可以用于存储指定类型的数据项,例如常用的字符串列表类 QStringList 就是从容器类 QLiSt<QString> 继承的,实现对字符串列表的添加、存储、删除等操作。 Qt 的容器...
  • Qt容器类

    2016-07-01 10:21:24
    Qt容器类By Xchen 20160629Qt提供一组通用的基于模板的容器类。 常见的Qt容器类为QListQ、LinkedList、QVector、QMap、QHash。 Qt容器类的两种风格迭代器 Java-style iterators STL- style iterators example01: ...
  • Qt容器类——概述

    2020-04-19 11:02:42
    1 Qt容器类 Qt提供了多个基于模板的容器类,用于存储指定类型的数据项。 Qt的容器类比STL中的要轻巧、安全,它们是隐式共享和可重入的,并进行了速度和存储优化,另外它们是线程安全的。 线程安全:作为只读容器...
  • Qt-容器类(笔记)

    2020-04-20 17:50:49
    文章目录一、Qt容器类简介1.1 关联容器与顺序容器1.2 嵌套与赋值二、遍历容器2.1 Java风格迭代器2.2 STL风格迭代器2.3 foreach关键字三、通用算法四、QString4.1 隐式共享4.2 编辑操作4.2 查询操作4.3 转换操作4.4...
  • 4. Qt容器类

    千次阅读 2014-12-21 08:49:19
     QList类、QLinkedList类和QVector类经常使用到的Qt容器类有QList、QLinkedList和QVector等。在开发一个较高性能需求的应用程序时,程序员会比较关注这些容器类的运行效率,下表列出了QList、QLinkedList和QVector...
  • Qt容器类之容器,迭代器

    千次阅读 2016-12-13 13:55:44
    此文乃《Qt中的C++技术》的读书笔记。若喜欢,请支持图书作者。QT中的容器被分为两个大:容器元素是一个值的,比如QVector,以及容器元素是一个(key, value)对的,比如QMap。
  • 关联容器(Associative Container)与顺序容器(Sequential Container)的本质区别在于:关联容器是通过键(key)存储和读取元素的,而顺序容器则通过元素在容器中的位置顺序存储和访问元素。 ...
  • QT 容器类

    2019-03-02 22:51:17
    Qt库提供了一套通用的基于模板的容器类,可以用这些类存储指定类型的项。比如,你需要一个大小可变的QString的数组,则使用QVector。 这些容器类比STL(C++标准模板库)容器设计得更轻量、更安全并且更易于使用。...
  • Qt容器类介绍

    2019-06-26 18:41:25
    Qt提供了多个基于模板的容器类,这些容器类可用于支持指定的数据类型,和STL容器相比,它们更加轻巧,安全,使用方便。这些容器类在很多方面进行了优化,例如优化速度,降低内存消耗,减少代码膨胀。它们都是隐式...
  • qt 容器类

    2016-01-22 01:43:12
    数组、链表、哈希……Qt中丰富的容器类 在C++里做大型程序时,少不了要与数组、链表等数据结构打交道。就是最简单的字符串也常常让头痛万分,Qt中有QString解决了字符串的头痛,那么其他数组等有没有更简单的解决...
  • Qt容器类学习笔记

    2016-10-13 14:49:00
    qt容器类的一个学习记录。
  • Qt容器类——QList

    千次阅读 2020-04-19 12:43:20
    注意Qt中有很多函数返回了QList类型,要遍历这些返回的容器,必须先复制再遍历。因为Qt使用了隐式复制,所以开销并不大。当一个迭代器在操作一个容器时,不要复制这个容器。 1. 初始化 QList<QString> list; ...
  • c++容器类&QT;容器

    2012-10-23 17:00:22
    C++中的容器类包括“顺序存储结构”和“关联存储结构”,前者包括vector,list,deque等;后者包括set,map,multiset,multimap等。 常用函数介绍等. 若需要存储的元素数在编译器间就可以确定,可以使用数组来...
  • Qt: 容器类和迭代器类、foreach关键字

    千次阅读 2016-07-18 01:40:36
    容器类和迭代器类提供 删除、修改、插入和保存数据的功能。 这两种类可以将各种数据类型的数据以元素为单位进行存储。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,087
精华内容 4,834
关键字:

qt所有的容器类