Qt(C/C++) 常用数据结构

QT是一个跨平台的图形化类库，常用数据结构就是对C++ STL的二次封装，使其更加易用

字符串容器

QString 追加/删除:

#pragma execution_character_set("utf-8")
#include <QCoreApplication>
#include <QString>
#include <QDebug>

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

    // 定义两个字符串并将其拼接在一起
    QString Str1 = "hello", Str2 = "Pan", temp;
    temp = Str1 + Str2;
    qDebug() << temp.toStdString().data();
    qDebug() << (Str1 + Str2).toStdString().data();

    // 使用字符串追加与移除
    QString Str3 = "hello";
    Str3.push_front("to ");         //push_front头部追加方法
    Str3.prepend("Welcome ");       //prepend头部追加方法
    Str3.append("Pan ");            //append尾部追加方法
    Str3.push_back("!");            //push_back尾部追加方法
    Str3.remove("hello");           //remove删除
    qDebug() << Str3.toStdString().data();

    // 使用Sprintf/arg 将特定字符串连接
    QString Str4;
    Str4.sprintf("%s %s", "Welcome", "to you !");
    qDebug() << Str4.toStdString().data();

    QString Str5;
    Str5 = QString("%1 is age =  %2 . ").arg("Pan").arg("18");
    qDebug() << Str5.toStdString().data();
    qDebug() << (QString("1") + QChar('A')).toStdString().data();
    qDebug() << (QString("2") + QString('B')).toStdString().data();

    //计算字符串的长度
    qDebug() << Str5.count();
    qDebug() << Str5.size();
    qDebug() << Str5.length();

    //去空格
    QString Str6 = " hello  Pan   welcome !  ";
    Str6 = Str6.trimmed();          // 去掉首尾空格
    Str6 = Str6.simplified();       // 去掉所有空格,中间连续的只保留一个
    qDebug() << Str6.toStdString().data();

    Str6 = Str6.mid(2, 10);         //从索引第2位开始向后取10位
    qDebug() << Str6.toStdString().data();

    //移除1，3两个位置的字符
    qDebug() << (QString("123456").remove(1, 3)).toStdString().data();

    //超过10个字符就保留10个字符，否则不足替换为 '.'
    qDebug() << (QString("abcdefg").leftJustified(10, '.', true)).toStdString().data();

    qDebug() << (QString::number(100, 16)).toStdString().data();    // 100转16进制

    //转换为16进制不足8位前面补‘0’
    qDebug() << (QString("%1").arg(123, 8, 16, QLatin1Char('0'))).toStdString().data();

    //转为8进制
    qDebug() << QString("%1").arg(QString::number(100, 8)).toStdString().data();
    //小数点位数设置
    qDebug() << (QString("%1").arg(QString::number(.777, 'f', 1))).toStdString().data();

    //切割字符串
    qDebug() << (QString("1,2,3,4,5,6").split(',')[2]).toStdString().data();

    //类型转换QByteArray转换QString
    QByteArray byte;
    byte.resize(2);     //设置大小
    byte[0] = '1';
    byte[1] = '2';
    QString strs = byte;
    qDebug() << strs.toStdString().data();

    return a.exec();
}

QString 查询/替换: 字符串的查询，替换，扫描与切割

#pragma execution_character_set("utf-8")
#include <QCoreApplication>
#include <QString>
#include <QDebug>

int main(int argc, char* argv[])
{
    QCoreApplication a(argc, argv);
    //查询与替换
    QString str = "hello Pan welcome to world";
    int index;
    bool ref;

    //查询字符串中是否包含特定字符
    ref = str.contains("Pan", Qt::CaseInsensitive);     // 不区分大小写
    qDebug() << ref;

    ref = str.contains("PAN", Qt::CaseSensitive);       // 区分大小写
    qDebug() << ref;

    //判断是否以某个字符串开头或结束
    ref = str.startsWith("hello", Qt::CaseInsensitive); // 判断是否hello开头
    qDebug() << ref;

    ref = str.endsWith("to", Qt::CaseSensitive);      // 判断是否to结尾
    qDebug() << ref;

    //从字符串中取左边/右边多少个字符
    index = str.indexOf(" ");        //第一个空格出现的位置
    qDebug() << str.left(index).toStdString().data();

    index = str.lastIndexOf(" ");    //最后一个空格出现的位置
    qDebug() << str.right(str.size() - index - 1).toStdString().data();

    //替换字符串中所有的world为CSDN
    str = str.replace("world", "CSDN");
    qDebug() << str.toStdString().data();

    // 字符串的截取
    QString str2 = "uname,uage,usex";
    qDebug() << str2.section(",", 0, 0).toStdString().data();
    qDebug() << str2.section(",", 1, 1).toStdString().data();

    //indexOf第一个参数是查询起始位置，第二个参数是显示位数
    QString str3 = "192.168.1.10";
    qDebug() << str3.left(str3.indexOf(".")).toStdString().data();
    qDebug() << str3.mid(str3.indexOf(".") + 1, 3).toStdString().data();
    qDebug() << str3.mid(str3.indexOf(".") + 1, 1).toStdString().data();
    qDebug() << str3.right(str3.size() - (str3.lastIndexOf(".") +         1)).toStdString().data();

    // 判断字符串是否为空
    QString str4, str5 = "";
    qDebug() << str4.isNull();    // 为空则为True
    qDebug() << str5.isNull();    // \0不为空
    qDebug() << str5.isEmpty();   // 为空则为False，不为空为true

    return a.exec();
}

QString 字符串转换:

#pragma execution_character_set("utf-8")
#include <QCoreApplication>
#include <QString>
#include <QDebug>

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

    QString str = "uname,uage,usex";
    QString int_str = "100,200,300";

    //大小写转换
    str = str.toUpper();            // 转为大写
    qDebug() << str.toStdString().data();
    str = str.toLower();            // 转为小写
    qDebug() << str.toStdString().data();

    //将字符串转为整数
    bool flag = false;
    QString x = int_str.section(",", 0, 0);   // 提取出第一个字符串

    int dec = x.toInt(&flag, 10);              // 转为十进制整数
    qDebug() << dec;

    int hex = x.toUInt(&flag, 16);            // 转为十六进制数
    qDebug() << hex;

    //将整数转为字符串
    int number = 100;
    QString number_str;
    number_str = number_str.setNum(number, 16);  // 转为十六进制字符串
    qDebug() << number_str.toStdString().data();

    //编码之间的转换
    QString str_string = "welcome to you !";

    QByteArray ba = str_string.toUtf8();
    qDebug() << ba.toStdString().data();

    //格式化输出转换
    float total = 3.1415926;
    QString str_total;

    //实例调用法
    str_total = str_total.sprintf("%.4f", total);
    qDebug() << str_total.toStdString().data();
    //静态调用法
    str_total = QString::asprintf("%2f", total);
    qDebug() << str_total.toStdString().data();

    return a.exec();
}

顺序容器
顺序容器 QList,QLinkedList,QVector,QStack,QQueue
qlist: 顺序容器,qlist是以下表的方式对数据进行访问的，可以使用下表索引的方式访问特定数据。

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


void Display(QList<QString> &ptr)
{
    qDebug() << "-----------------------------";
    for (qint32 x = 0; x < ptr.count(); x++)
    {
        qDebug() << (ptr.at(x)).toStdString().data();
    }
    qDebug();
}

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

    QList<QString> StringPtrA;
    QList<QString> StringPtrB;

    // 添加三个成员
    StringPtrA.append("admin");
    StringPtrA.append("guest");
    StringPtrA.append("Pan");
    Display(StringPtrA);

    // 在首部插入hanter
    StringPtrA.prepend("hanter");
    Display(StringPtrA);

    // 在第0的位置插入lucy
    StringPtrA.insert(0, QString("lucy"));
    Display(StringPtrA);

    // 替换原来的admin为全拼
    StringPtrA.replace(1, "Administrator");
    Display(StringPtrA);

    // 删除第0个元素
    StringPtrA.removeAt(0);
    Display(StringPtrA);

    // 删除首部和尾部
    StringPtrA.removeFirst();
    StringPtrA.removeLast();
    Display(StringPtrA);

    // 移动两个变量
    StringPtrA.move(0, 1);
    Display(StringPtrA);

    // 将两个list容器对调交换
    StringPtrB = { "hello","hi" };
    StringPtrA.swap(StringPtrB);
    Display(StringPtrA);
    return a.exec();
}

qlist可以指定一个struct结构进行数据操作

#include <QCoreApplication>
#include <QLinkedList>
#include <QLinkedListIterator>
#include <QMutableLinkedListIterator>
#include <QDebug>

struct MyStruct
{
    qint32 uid;
    QString uname;
};

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

    QList<MyStruct> ptr;
    MyStruct str_ptr;

    str_ptr.uid = 1001;
    str_ptr.uname = "admin";
    ptr.append(str_ptr);

    str_ptr.uid = 1002;
    str_ptr.uname = "guest";
    ptr.append(str_ptr);

    //使用传统方式遍历数据
    for(qint32 x=0;x<ptr.count();x++)
    {
        qDebug() << ptr.at(x).uid;
        qDebug() << ptr[x].uname.toStdString().data();
    }

    //使用只读迭代器遍历
    QListIterator<MyStruct> x(ptr);
    while(x.hasNext())
    {
        // peeknext读取下一个节点,但不影响指针变化
        qDebug() << x.peekNext().uid;
        qDebug() << (x.peekNext().uname).toStdString().data();
        // 最后将x指针指向下一个数据
        x.next();
    }

    //使用读写迭代器:如果uid=1002则将guest改为Pan
    QMutableListIterator<MyStruct> y(ptr);
    while(y.hasNext())
    {
        if(y.peekNext().uid == 1002)
        {
            y.peekNext().uname = "Pan";
        }
        y.next();
    }
    return a.exec();
}

qlinklist:qlinklist就是动态链表结构，数据的存储非连续，访问时无法直接使用下标定位，只能通过迭代器迭代寻找，参数定义与qlist基本一致。

#include <QCoreApplication>
#include <QLinkedList>
#include <QLinkedListIterator>
#include <QMutableLinkedListIterator>
#include <QDebug>

struct MyStruct
{
    qint32 uid;
    QString uname;
};

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

    QLinkedList<MyStruct> ptr;
    MyStruct str_ptr;

    str_ptr.uid = 1001;
    str_ptr.uname = "admin";
    ptr.append(str_ptr);

    str_ptr.uid = 1002;
    str_ptr.uname = "guest";
    ptr.append(str_ptr);


    //使用只读迭代器遍历: 从前向后遍历
    QLinkedListIterator<MyStruct> x(ptr);
    while(x.hasNext())
    {
        qDebug() << x.peekNext().uid;
        x.next();
    }

    //使用只读迭代器遍历: 从后向前遍历
    for(x.toBack();x.hasPrevious();x.previous())
    {
        qDebug() << x.peekPrevious().uid;

    }

    // 使用STL风格的迭代器遍历
    QLinkedList<MyStruct>::iterator y;
    for(y=ptr.begin(); y!=ptr.end(); ++y)
    {
        qDebug() << (*y).uid;
    }

    //STL风格的只读迭代器
    QLinkedList<MyStruct>::const_iterator z;
    for(z=ptr.constBegin(); z!=ptr.constEnd(); ++z)
    {
        qDebug() <<((*z).uname).toStdString().data();
    }

    //使用读写迭代器: 动态生成列表,每次对二取余
    QLinkedList<int> Number = {1,2,3,4,5,6,7,8,9,10};
    QMutableLinkedListIterator<int> item(Number);

    //--> 从前向后输出一次
    for(item.toFront();item.hasNext();item.next())
        qDebug() << item.peekNext();

    //--> 将指针移动到最后然后判断
    for(item.toBack();item.hasPrevious();)
    {
        if(item.previous() % 2==0)
            item.remove();
        else
            item.setValue(item.peekNext() * 10);
    }

    //--> 最后输出出相加后的结果
    for(item.toFront();item.hasNext();)
    {
        qDebug() << item.peekNext();
        item.next();
    }
    return a.exec();
}

QVector:该容器在相邻内存中存储连续的数据，该方式的使用与Qlist完全一致，但性能要比Qlist更高，但在插入时速度最慢

#include <QCoreApplication>
#include <QDebug>
#include <QVector>
#include <QVectorIterator>
#include <QMutableVectorIterator>

struct MyStruct
{
    qint32 uid;
    QString uname;
};

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

    QVector<MyStruct> ptr;
    MyStruct str_ptr;

    str_ptr.uid = 1001;
    str_ptr.uname = "admin";
    ptr.append(str_ptr);

    str_ptr.uid = 1002;
    str_ptr.uname = "guest";
    ptr.append(str_ptr);

    //使用传统方式遍历
    for (qint32 x = 0; x < ptr.count(); x++)
    {
        qDebug() << ptr.at(x).uid;
        qDebug() << ptr[x].uname.toStdString().data();
    }

    //使用只读迭代器遍历: C++ STL写法
    QVector<MyStruct>::const_iterator item;
    for (item = ptr.begin(); item != ptr.end(); ++item)
    {
        qDebug() << (*item).uid;
        qDebug() << (*item).uname.toStdString().data();
    }

    //使用读写迭代器修改: C++ STL写法
    QVector<MyStruct>::iterator write_item;
    for (write_item = ptr.begin(); write_item != ptr.end(); ++write_item)
    {
        if ((*write_item).uid == 1001)
        {
            (*write_item).uname = "xxxx";
        }
        qDebug() << (*write_item).uid;
        qDebug() << (*write_item).uname.toStdString().data();
    }

    return a.exec();
}

QStack:qstack时堆栈结构先进后出

#include <QCoreApplication>
#include <QDebug>
#include <QString>
#include <QStack>
#include <QQueue>

struct MyStruct
{
    qint32 uid;
    QString uname;
};

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

    //定义并弹出QString类型数据
    QStack<QString> stack;

    stack.push("admin");
    stack.push("guest");

    qDebug() << (stack.top()).toStdString().data();
    while (!stack.isEmpty())
    {
        qDebug() << (stack.pop()).toStdString().data();
    }

    //定义并弹出一个结构类型数据
    QStack<MyStruct> struct_stack;
    MyStruct ptr;

    ptr.uid = 1001;
    ptr.uname = "admin";
    struct_stack.push(ptr);

    ptr.uid = 1002;
    ptr.uname = "guest";
    struct_stack.push(ptr);

    //分别弹出数据并输出
    while (!struct_stack.isEmpty())
    {
        MyStruct ref;

        ref = struct_stack.pop();
        qDebug() << "uid = " << ref.uid;
        qDebug() << "uname = " << ref.uname.toStdString().data();
    }

    return a.exec();
}

QQueue: qqueue 队列，先进先出

#include <QCoreApplication>
#include <QDebug>
#include <QString>
#include <QQueue>

struct MyStruct
{
    qint32 uid;
    QString uname;
};

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

    QQueue<MyStruct> ptr;
    MyStruct queue_ptr;

    //实现对结构体的入队
    queue_ptr.uid = 1001;
    queue_ptr.uname = "admin";
    ptr.enqueue(queue_ptr);

    queue_ptr.uid = 1002;
    queue_ptr.uname = "guest";
    ptr.enqueue(queue_ptr);

    //实现对结构体的出队
    while (!ptr.isEmpty())
    {
        MyStruct ref;

        ref = ptr.dequeue();
        qDebug() << "uid = " << ref.uid;
        qDebug() << "uname = " << ref.uname.toStdString().data();
    }

    return a.exec();
}

关联容器
关联容器: qmap，qmultimap，qhash，qmultihash，qmultihash，qset
qmap/qmultimap:提供了一个字典类型的关联数组，一个键映射一个值，qmap是按照顺序存储的，如果不在意顺序可以使用qhash，使用qhash效率更高

#include <QCoreApplication>
#include <QDebug>
#include <QString>
#include <QtGlobal>
#include <QMap>
#include <QMapIterator>

struct MyStruct
{
    qint32 uid;
    QString uname;
};

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

    QMap<QString, QString> map;

    map["1001"] = "admin";
    map["1002"] = "guest";
    map.insert("1003", "lili");
    map.insert("1004", "lucy");

    //根据键值对查询属性
    qDebug() << map["1002"].toStdString().data();
    qDebug() << map.value("1003").toStdString().data();
    qDebug() << map.key("admin").toStdString().data();

    //使用STL语法迭代枚举Map键值对
    QMap<QString, QString>::const_iterator x;
    for (x = map.constBegin(); x != map.constEnd(); ++x)
    {
        qDebug() << x.key().toStdString().data() << " : ";
        qDebug() << x.value().toStdString().data();
    }

    //使用STL语法实现修改键值对
    QMap<QString, QString>::iterator write_x;
    write_x = map.find("1003");
    if (write_x != map.end())
        write_x.value() = "you ary in";

    //使用QTglobal中自带的foreach遍历键值对
    QString each;

    //--> 单循环遍历
    foreach(const QString & each, map.keys())
    {
        qDebug() << map.value(each).toStdString().data();
    }

    //--> 多循环遍历
    foreach(const QString & each, map.uniqueKeys())
    {
        foreach(QString x, map.value(each))
        {
            qDebug() << each.toStdString().data() << " : ";
            qDebug() << x.toStdString().data();
        }
    }

    return a.exec();
}

qmultimap是qmap的子集，用于处理多值映射的类

#include <QCoreApplication>
#include <QDebug>
#include <QString>
#include <QList>
#include <QMultiMap>


struct MyStruct
{
    qint32 uid;
    QString uname;
};

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

    QMultiMap<QString, QString> mapA, mapB, mapC, mapD;

    mapA.insert("Pan", "1000");
    mapA.insert("Pan", "2000");
    mapB.insert("admin", "3000");
    mapB.insert("admin", "4000");
    mapC.insert("admin", "5000");

    //获取到里面的所有key=Pan的值
    QList<QString> ref;

    ref = mapA.values("Pan");
    for (int x = 0; x < ref.size(); ++x)
    {
        qDebug() << ref.at(x).toStdString().data();
    }

    //两个key相同可相加后输出
    mapD = mapB + mapC;

    ref = mapD.values("admin");
    for (int x = 0; x < ref.size(); x++)
    {
        qDebug() << ref.at(x).toStdString().data();
    }

    return a.exec();
}

qhash使用上与qmap相同，但qhash效率更高，唯一的不同时qhash不排序，qmap自动排序
qset: qset 集合容器，是基于散列表的集合模板，存储顺序不定，查找速度最快，内部使用qhash实现

#include <QCoreApplication>
#include <QDebug>
#include <QString>
#include <QSet>

struct MyStruct
{
    qint32 uid;
    QString uname;
};

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

    QSet<QString> set;

    set << "dog" << "cat" << "tiger";

    //测试某值是否包含于集合
    if (set.contains("cat"))
    {
        qDebug() << "include";
    }

    return a.exec();
}

将qlist与qmap结合使用，实现嵌套 , 在qmap中存储一个qlist数据

#include <QCoreApplication>
#include <QDebug>
#include <QString>
#include <QtGlobal>
#include <QList>
#include <QMap>

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

    QMap<QString, QList<float>> map;
    QList<float> ptr;

    //指定第一组数据
    ptr.append(10.1);
    ptr.append(12.5);
    ptr.append(22.3);
    map["10:10"] = ptr;

    //指定第二组数据
    ptr.clear();
    ptr.append(102.2);
    ptr.append(203.2);
    ptr.append(102.1);
    map["11:20"] = ptr;

    //输出所有的数据
    QList<float> tmp;
    foreach(QString each, map.uniqueKeys())
    {
        tmp = map.value(each);
        qDebug() << "Time: " << each.toStdString().data();
        for (qint32 x = 0; x < tmp.count(); x++)
        {
            qDebug() << tmp[x];
        }
    }

    return a.exec();
}

将两个qlist合并为一个qmap，将列表合并为一个字典

#include <QCoreApplication>
#include <QDebug>
#include <QString>
#include <QtGlobal>
#include <QList>
#include <QMap>

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

    QList<QString> Header = { "MemTotal","MemFree","Cached","SwapTotal","SwapFree" };
    QList<float> Values = { 12.5,46.8,68,100.3,55.9,86.1 };
    QMap<QString, float> map;

    //将列表合并为一个字典
    for (int x = 0; x < Header.count(); x++)
    {
        QString head = Header[x].toStdString().data();
        float val = Values[x];
        map[head] = val;
    }

    //输出特定字典中的数据
    qDebug() << map.key(100.3).toStdString().data();
    qDebug() << map.value("SwapTotal");

    return a.exec();
}

反之，将字典拆分为一个列表

#include <QCoreApplication>
#include <QDebug>
#include <QString>
#include <QtGlobal>
#include <QList>
#include <QMap>

void Display(QMap<QString, float> map)
{
    foreach(const QString & each, map.uniqueKeys())
    {
        qDebug() << each.toStdString().data();
        qDebug() << map.value(each);
    }
}

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

    QMap<QString, float> map;

    map["MemTotal"] = 12.5;
    map["MemFree"] = 32.1;
    map["Cached"] = 19.2;

    Display(map);

    QList<QString> map_key;
    QList<float> map_value;

    //分别存储起来
    map_key = map.keys();
    map_value = map.values();

    //输出所有的key值
    for (int x = 0; x < map_key.count(); x++)
    {
        qDebug() << map_key[x].toStdString().data();
    }

    //输出所有的value值
    for (int x = 0; x < map_value.count(); x++)
    {
        qDebug() << map_value[x];
    }

    return a.exec();
}

排序结构体：

#include <QCoreApplication>
#include <QDebug>
#include <QString>
#include <QtGlobal>
#include <QList>

struct MyStruct
{
    int uuid;
    QString uname;
};

void Display(QList<int> ptr)
{
    foreach(const int& each, ptr)
        qDebug() << each << " ";
    qDebug();
}

//由大到小排列
int compare(const int& infoA, const int& infoB)
{
    return infoA > infoB;
}

//针对结构体的排序方法
void devListSort(QList<MyStruct>* list)
{
    std::sort(list->begin(), list->end(), [](const MyStruct& infoA, const MyStruct& infoB)
        {
            return infoA.uuid < infoB.uuid;
        });
}

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

    //定义并对单一数组排序
    QList<int> list = { 56,88,34,61,79,82,34,67,88,1 };
    std::sort(list.begin(), list.end(), compare);
    Display(list);

    //定义并对结构体排序
    QList<MyStruct> list_struct;
    MyStruct ptr;

    ptr.uuid = 1005;
    ptr.uname = "admin";
    list_struct.append(ptr);

    ptr.uuid = 1002;
    ptr.uname = "guest";
    list_struct.append(ptr);

    ptr.uuid = 1000;
    ptr.uname = "Pan";
    list_struct.append(ptr);

    devListSort(&list_struct);

    for (int x = 0; x < list_struct.count(); x++)
    {
        qDebug() << list_struct[x].uuid << " ---> ";
        qDebug() << list_struct[x].uname.toStdString().data();
    }

    return a.exec();
}

正则表达式模块：

#include <QCoreApplication>
#include <QDebug>
#include <QString>
#include <QtGlobal>

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

    //返回绝对值
    qDebug() << qAbs(10.5);

    //返回较大者
    qDebug() << qMax(12, 56);

    //返回较小者
    qDebug() << qMin(22, 56);

    //返回随机数
    double x = 6.7, y = 3.5;
    int ref = qRound(x);
    qDebug() << ref;

    //交换位置
    qSwap(x, y);
    qDebug() << x;

    return a.exec();
}