Qt编程指南
- [■ 顺序容器类](#■ 顺序容器类)
-
- [■ QList](#■ QList)
- [■ QVector](#■ QVector)
- [■ QLinkedList](#■ QLinkedList)
- [■ QStack](#■ QStack)
- [■ QQueue](#■ QQueue)
- [■ 关联容器类](#■ 关联容器类)
-
- [■ QSet](#■ QSet)
- [■ QMap](#■ QMap)
- [■ QMultiMap](#■ QMultiMap)
- [■ QHash](#■ QHash)
- [■ QMultiHash](#■ QMultiHash)
■ 顺序容器类
■ QList
c
复制代码
QList 比较常用的容器类，以数组列表的形式实现，在前、后添加数据非常快。以下为常用方法。
QList<QString> list;
插入：insert() //list.insert(2, "mm"); // 在位置2插入项目 list << "aa" << "bb" << "cc"; // 插入项目
删除：removeAt(i) //i 是下标
删除第3个 QString str = list.takeAt(2); // 从列表中删除第3个项目，并获取它
替换：replace() //替换第3个元素 list.replace(2, "bc");
交换: swap() // list.swap(1,3); // 交换项目1和项目3
移动：move()
添加：append() // list.append("dd"); // 在列表尾部添加
头部添加: prepend("mm") list.prepend("mm"); // 在列表头部添加
包含: list.contains("mm"); //列表中是否包含"mm"
列表包含某值个数: list.count("mm"); 包含"mm"的个数
查找 : list.indexOf("mm"); // 第一个"mm"的位置，默认从位置0开始往前查找 ，返回第一个匹配的项目的位置
往前查找: list.indexOf("mm", 2); // 第二个"mm"的位置，我们指定从位置1开始往前查找
QList<QString> list;
list << "A" << "B" << "C" << "B" << "A";
list.indexOf("B"); // returns 1
list.indexOf("B", 1); // returns 1
list.indexOf("B", 2); // returns 3
list.indexOf("X"); // returns -1
bool QList::empty() const表为空，则返回true
list.begin(), list.end()
for(int i=0; i<list.size(); ++i)
{
qDebug() << list.at(i);
}
QList<int> z;
z <<1<<2<<3<<4; // z对应的值z[0] = 1;z[1] = 2;z[2] = 3;z[3] = 4;
QList<int> z;
z <<1<<2<<3<<4;
z.removeAt(1); //删除下标为1后,z对应的值z[0] = 1;z[1] = 3;z[2] = 4;
#include <QCoreApplication>
#include <QList>
#include <QDebug>
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
QList<QString> list;
list << "aa" << "bb" << "cc"; // 插入项目
if(list[1] == "bb") list[1] = "ab";
list.replace(2, "bc"); // 将"cc"换为"bc"
qDebug() << "the list is: "; // 输出整个列表
for(int i=0; i<list.size(); ++i){
qDebug() << list.at(i); // 现在列表为aa ab bc
}
list.append("dd"); // 在列表尾部添加
list.prepend("mm"); // 在列表头部添加
QString str = list.takeAt(2); // 从列表中删除第3个项目，并获取它
qDebug() << "at(2) item is: " << str;
qDebug() << "the list is: ";
for(int i=0; i<list.size(); ++i)
{
qDebug() << list.at(i); // 现在列表为mm aa bc dd
}
list.insert(2, "mm"); // 在位置2插入项目
list.swap(1,3); // 交换项目1和项目3
qDebug() << "the list is: ";
for(int i=0; i<list.size(); ++i)
{
qDebug() << list.at(i); // 现在列表为mm bc mm aa dd
}
qDebug() << "contains 'mm' ?" << list.contains("mm"); // 列表中是否包含"mm"
qDebug() << "the 'mm' count: " << list.count("mm"); // 包含"mm"的个数
// 第一个"mm"的位置，默认从位置0开始往前查找，返回第一个匹配的项目的位置
qDebug() << "the first 'mm' index: " << list.indexOf("mm");
// 第二个"mm"的位置，我们指定从位置1开始往前查找
qDebug() << "the second 'mm' index: " << list.indexOf("mm", 1);
return a.exec();
}
■ QVector
c
复制代码
append函数或者<<操作符来在数组最后端添加元素而不用担心溢出问题。
定义 QVector <int> array(10) ； array[5]=4;
加元素 strArray.append("Hello"); //可以这样
加元素 strArray<<"World!"; //也可以这样
插入： strArray.insert(1,"这就是在hello和world之间添加");
删除： strArray.remove(1); //删除第一个元素，从0开始 strArray.remove(1，3); //从1开始，删除3个元素
复制（取代）： strArray.replace(1,"LEO"); //删除第一个元素，从0开始
是否含有contains()函数是用来查找向量容器内是否含有某个对象。
count()函数可以找出某个对象出现的次数。
resize()函数可以在任何时候改变QVector向量容器的体积
capacity()函数会告诉你向量容器所占内存的实际大小空间。
判断是否包含某元素 qDebug()<< Array.contains(12);
末端添加元素：
QVector<int> Array;
Array<<3; //第一种方式
Array.append(5); //第二种方式
种方式
QVector<int>::iterator num;
for (num=Array.begin(); num!=Array.end(); num++)
{
qDebug()<< *num;
}
//第二种方式
for (int i=0; i<Array.count(); i++)
{
qDebug()<< Array[i];
}
QVector<QString> strArray;
■ QLinkedList
c
复制代码
是链式列表，数据项不是连续的内存存储，基于迭代器访问数据项，插入和删除数据项操作时间相同
QLinkedList<QString> list;
list<<"1"<<"2"<<"3"<<"4";
// foreach正序：
QString str;
foreach (str, list)
qDebug() << str;
// 迭代器正序
QLinkedList<QString>::iterator it;
for(it = list.begin(); it != list.end(); ++it){
qDebug() << *it;
}
// 迭代器倒序
QLinkedList<QString>::const_iterator it = list.constEnd();
while (it != list.constBegin())
{
--it;
qDebug()<<*it;
}
移除某个节点
list.removeOne("4");
列表大小
list.size()
链头位置插入
list.push_front("5");
链尾位置插入
list.push_back("5");
清空
list.clear();
■ QStack
c
复制代码
类似于堆栈，后入先出的特点，push()和pop()用于数据进出栈。
QStack <int> s; //定义一个int型栈
s. isEmpty(); //返回栈是否为空
s.size(); //返回当前栈中元素的个数
s.push(); //在栈顶上堆进一个元素
s.pop(); //删除掉栈顶上的元素,并返回这个元素
s.top(); //返回栈顶的元素,并不会删除
T & operator[] ( int i ); //以数组形式访问队列元素
QStack<int> stack;
stack.push(1);
stack.push(2);
stack.push(3);
while(!stack.isEmpty())
stack.pop();
■ QQueue
c
复制代码
它的父类是QList,是个模板类
类似于队列，先入先出的特点，enqueue()和dequeue()用于操作数据进出队列。
QQueue<int> Q; //定义一个int型队列
Q.isEmpty(); //返回队列是否为空
Q.size(); //返回队列元素个数
Q.clear(); //清空队列
Q.enqueue(); //在队列尾部添加一个元素, 比如插入数字5: Q.enqueue(5)
Q.dequeue(); //删除当前队列第一个元素,并返回这个元素
Q.head(); //返回当前队列第一个元素
Q.last(); //返回当前队列尾部的元素
T & operator[]( int i ); //以数组形式访问队列元素
QQueue<int> queue;
queue.enqueue(1);
queue.enqueue(2);
queue.enqueue(3);
while(!queue.isEmpty())
queue.dequeue();
■ 关联容器类
■ QSet
c
复制代码
基于散列表的集合模板类，存储数据的顺序不定，查找速度非常快。
QSet类是一个模板类，他是一个哈希表集合。QSet<T>是Qt的一个普通容器类。QSet存储的值是不指明顺序的，QSet对这些值提供了快速检索的功能。他和QHash很像PS：Set就是键值一样的Hash
QSet<QString> set;
set.insert("one");
set.insert("three");
set << "twelve" << "fifteen" << "nineteen";
使用contains()判断set中是否存在某一项：
if (!set.contains("ninety-nine"))
遍历整个set
QSetIterator<QWidget *> i(set);
while (i.hasNext())
qDebug() << i.next();
QSet<QWidget *>::const_iterator i = set.constBegin();
while (i != set.constEnd()) {
qDebug() << *i;
++i;
}
QSet<QString> set;
foreach (const QString &value, set)
qDebug() << value;
#include <QtCore/QCoreApplication>
#include <QSet>
#include <QDebug>
class Data{
public:
Data(const QString &strVal, const int &intVal){
StrVal = strVal;
IntVal = intVal;
}
QString StrVal;
int IntVal;
friend QDebug operator << (QDebug os, Data data){
os << "(" << data.StrVal << " ,"
<< data.IntVal << ")";
return os;
}
};
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
QSet<Data*> dataSet;
dataSet.insert(new Data("ABC", 0));
dataSet.insert(new Data("DEF", 1));
dataSet << new Data("AAA", 2);
dataSet << new Data("CCC", 3);
//Java style
QSetIterator<Data *> i(dataSet);
while(i.hasNext())
qDebug() << *(i.next());
//STL style
QSet<Data*>::const_iterator stlI = dataSet.constBegin();
while(stlI != dataSet.constEnd()){
qDebug() << **stlI;
delete *stlI;
stlI++;
}
return a.exec();
}
■ QMap
c
复制代码
QMap存储数据按照键的顺序来存储的，一个键映射一个值。
QMap<int,int> map;
map[1] = 1;
map[2] = 2;
map[3] = 3;
//或者使用insert
QMap<int,int> map;
map.insert(1,1);
map.insert(2,2);
map.insert(3,3);
int num = map[1]; //或者 int num2 = map.value[2];
■ QMultiMap
c
复制代码
是QMap的子类，一个键可以对应多个值。
QMultiMap<int,int> map;
map.insert(1,1);
map.insert(1,2);
//map.size() == 2
■ QHash
c
复制代码
基于散列表来实现的,查找速度非常快。
和QMap比较
QHash查找速度更快
QMap是按键顺序排序的，QHash数据项任意排序
创建,键值对的方式插入，数据类型随意，这里以键int，值QString示例。
QHash<int,QString> qhash;
//方式一
qhash[1] = "1";
qhash[2] = "2";
qhash[3] = "3";
//方式二
qhash.insert(4, "4");
通常，QHash 每个键只允许有一个值。如果用已经存在的键调用 insert()，先前的值将被删除
qhash.insert(4,"10);
最后键为4的值将变成"10"。
取值；
//方式一
QString str1=qhash.value(1);//str1="1";
//方式二
QString str2=qhash[2];//str1="2";
如果qhash里面没有该键值，则返回默认构造值；比如：QString str3=qhash.value(5);//str3="";
检索某个值是否在里面
if(qhash.contains(9))
{
return false;
}
if(qhash.contains(1))
{
return true;
}
查找某个字并获取，一般推荐contains结合value重载函数来实现，
QString str;
if(qhash.contains(1))
{
str=qhash.value(1);
}
else
{
str=qhash.value(1,"wert");
//如果哈希表中不存在指定键的元素，该函数使用第2个参数作为默认值
}
QHash<int,QString>::const_iterator it = qhash.constBegin();
while (it != qhash.constEnd()) {
cout << it.key() << ": " << it.value() << Qt::endl;
++i;
}
当然不用const_iterator也可以，直接iterator;
删除,下面两种都可以
qhash.erase(it);//这里的it是迭代器哦
qhash.remove(key);
■ QMultiHash
c
复制代码
QMultiHash是QHash的子类，用于处理多值映射的类，与QMultiMap类似。