QT容器

#include <QCoreApplication>

#include<qdebug.h>

int main(int argc, char *argv[])

{

    /*

     *                          Java风格的迭代器

     *      QList<T>,QQueue<T>      QListIterator<T>            QMutableListIterator<T>

     *      QLinkedList<T>          QLinkedListIterator<T>      QMutableLinkedListIterator<T>

     *      QVector<T>,QStack<T>    QVectorIterator<T>          QMutableVectorIterator<T>

     *

     *

     * */

    QList<int> m_list;

    m_list<<1<<2<<3<<4;

    //Java风格的迭代器

    QListIterator<int> m_iterator(m_list);

    //正向迭代

    for(;m_iterator.hasNext();)

    {

        qDebug()<<m_iterator.next();

    }

    //反向迭代

    m_iterator.toBack();

    for(;m_iterator.hasPrevious();)

    {

          qDebug()<<m_iterator.previous();

    }

    QMutableListIterator<int> m_nutableIterator(m_list);

    for(m_nutableIterator.toBack();m_nutableIterator.hasPrevious();)

    {

      if(m_nutableIterator.previous()==3)

       {

           m_nutableIterator.setValue(30);//设置当前列表项

           m_nutableIterator.insert(55);//添加到当前列表项之后

       }

    }

    for(m_nutableIterator.toBack();m_nutableIterator.hasPrevious();)

    {

        qDebug()<<m_nutableIterator.previous();

    }

    /*

     *                    STL风格的迭代器

     *      QList<T>,QQueue<T>       QList<T>::const_iterator            Qlist<T>::iterator

     *      QLinkedList<T>           QLinkedList<T>::const_iterator      QLinkedList<T>::iterator

     *      QVector<T>,QStack<T>     QVector<T>::const_iterator          QVector<T>::iterator

     *

     *      STL风格的迭代器是建立在指针的基础之上的，++表示下一项，*返回迭代器指向的项

     * */

     qDebug()<<"------------------------------------------";

    QList<int> m_iList;

    for(int i=0;i<10;i++)

    {

        m_iList.insert(m_iList.end(),i);

    }

    QList<int>::const_iterator m_constIterator;

    for(m_constIterator = m_iList.begin();m_constIterator!=m_iList.end();m_constIterator++)

    {

        qDebug()<<(*m_constIterator);

    }

    /*

     *              容器类                                只读迭代器                   读写迭代器

     * QMap<key,value>,QMultiMap<key,value>     QMapIterator<key,value>     QMultableMapIterator<key,value>

     * QHash<key,value>,QMultiHash<key,vaue>    QHashIterator<key,value>    QMultalbeHashIterator<key,value>

     *

     * */

    qDebug()<<"-----------------------------------";

    QMap<int,QString> m_map;

    m_map.insert(1,"A");

    m_map.insert(2,"B");

    m_map.insert(3,"C");

    m_map.insertMulti(1,"AA");

    m_map.insert(1,"AAA");

    QMapIterator<int,QString> m_javaIterator(m_map);

    for(m_javaIterator.toFront();m_javaIterator.hasNext();)

    {

        qDebug()<<m_javaIterator.key()<<m_javaIterator.next().value();

    }

    qDebug()<<"-----------------------------------";

    QMutableMapIterator<int,QString> m_mutable(m_map);

    if(m_mutable.findNext("B"))

        m_mutable.setValue("BB");

    for(m_mutable.toFront();m_mutable.hasNext();)

    {

        qDebug()<<m_mutable.key()<<m_mutable.next().value();

    }

    /*

     *                                                      STL

     *              容器类                                只读迭代器                   读写迭代器

     * QMap<key,value>,QMultiMap<key,value>     QMap<int,QString>::const_iterator     QMap<int,key>::iterator

     * QHash<key,value>,QMultiHash<key,vaue>    QHash<key,value>::const_iterator      QHash<key,value>::iterator

     *

     * */

     QMap<int,QString>::const_iterator m_pIterator;

     for(m_pIterator = m_map.begin();m_pIterator!= m_map.end();m_pIterator++)

     {

         qDebug()<<m_pIterator.key()<<m_pIterator.value();

     }

     qDebug()<<"-----------------------------------";

     QVariant x;

     x= 10.0;

    qDebug()<<x;

    QMap<QVariant,QVariant> m_variant;

    m_variant.insert("12",2);

    m_variant.insert(1,"dd");

    m_variant.insert(1.2,4);

    QMap<QVariant,QVariant>::const_iterator m_variantIterator;

    for(m_variantIterator = m_variant.begin();m_variantIterator != m_variant.end();m_variantIterator++)

    {

        qDebug()<<m_variantIterator.key()<<m_variantIterator.value();

    }

    /*

     *  正则表达式由 表达式、量词、断言 组成

     *

     *                      正则表达式的量词

     *   E?      匹配0或1次                   E[n,]      至少匹配n次

     *   E+      匹配1次或多次                 E[,m]      最多匹配m次

     *   E*      匹配0次或多次即 任意次         E[n,m]     至少匹配n次且最多匹配m次

     *   E[n]    匹配 n 次

     *

     *

     *                      正则表达式的断言

     *  ^表示在字符串开头开始匹配       \B      非单词边界

     *  $表示在字符串结尾进行匹配       (?=E)   表示表达式后紧随E才匹配

     *  \b 单词边界                   (?!E)   表示表达式后不跟随E才匹配

     * */

    return 0;

}