精华内容
下载资源
问答
  • qstring
    千次阅读
    2018-07-12 10:57:35

    原地址:https://blog.csdn.net/qq_40194498/article/details/79629632

    QString在Qt的各种数据转换中可谓举足轻重,熟悉QString的用法对于Qt编程真的是如虎添翼:



    QString 字符串有相当多的操作符和函数,此处只介绍一些比较常用的:


    (1) “+” 用于组合两个字符串,“+=” 用于将一个字符串追加到另一个字符串的末尾,例如:


     QString str1 = "Welcome";
     str1 = str1 + "to you !";   //str1 = "Welcome to you!"
     QString str2 = "Hello,";
     str2 += "World!";      //str2 = "Hello,World!"
    1
    2
    3
    4
    (2)QString::append()函数,具有与“+=”操作符同样的功能,实现字符串末尾追加另一个字符串,例如:


     QString str1 = "Welcome ";
     QString str2 = "to ";
     str1.append(str2);             //str1 = "Welcome to "
     str1.append("you !");         //str1 = "Welcome to you !" 
    1
    2
    3
    4
    (3)组合字符串的另一个函数是QString::sprintf(),此函数支持的格式定义和C++库中的函数sprintf()定义一样,例如:


     QString str;
     str.sprintf("%s","Welcome ");     //str = "Welcome "
     str.sprintf("%s"," to you! ");      //str = " to you! "
     str.sprintf("%s %s","Welcome "," to you! ");     //str = "Welcome  to you! "; 
    1
    2
    3
    4
    (4)Qt还提供了另一种方便的字符串组合方式,使用QString::arg()函数,此函数的重载可以处理很多的数据类型。此外,一些重载具有额外的参数对字段的宽度、数字基数或者浮点精度进行控制。相对于QString::sprintf(),QString::arg()是一个比较好的解决方案,因为它类型安全,完全支持Unicode,并且允许改变“/n”参数的顺序。例如:


     QString str;
     str = QString("%1 was born in %2.").arg("Joy").arg(1993);     //str =  "Joy was born in 1993.";
    1
    2
    其中:


      “%1” 被替换为“Joy”.


      “%2”被替换为“1993”.


    (5)QString 也提供了一些其他的组合字符串的方法,包括以下几种:


      a. insert()函数:在原字符串特定位置插入另一个字符


      b. prepend()函数:在原字符串开头插入另一个字符串


      c. replace()函数:用指定的字符串去代替原字符串中的某些字符


    (6)去除字符串两端的空白(空白字符包括回车符号“\n”、换行符“\r”、制表符”\t”和空格字符:“ ”等)非常常用,如获取用户输入账号时就需要去掉空白符。


      a. QString::trimmed()函数:移除字符串两端的空白符


      b. QString::simplified()函数:移除字符串两端的空白字符,使用单个空格字符“ ”代替字符串中出现的空白字符。


    例如:


     QString str1 = "   Welcome  \t  to  \n  you!   ";
     QString str2 = "   Welcome  \t  to  \n  you!   ";
     str1 = str1.trimmed();      // str1 = " Welcome \t to \n you! "
     str2 = str2.simplified();     // str2 = " Welcome to you ! " 
    1
    2
    3
    4
    (7)split函数用于拆分字符串


        QByteArray array = tcpSocket->readAll();//从套接字读取数据
        QString strr = array;//将数据转换为QString格式
        QStringList strlist=strr.split(" ");//将数据以空格拆分,并放入数组中
        QStringList list=strlist.at(1).split("#");//将strlist中的第一号元素以“#”隔开并存入list中
        qDebug()<<list.at(0);//打印出list中的首个元素
    1
    2
    3
    4
    5
    (8)clear用于清除字符串


    str = "hello"; 
    str.clear();//此后字符串为空
    1
    2
    (9)indexOf函数用于在一个字符串中查找另一个字符串,返回第一次出现的索引位置,如果没有找到,返回-1。


    QString x = "sticky question";
    QString y = "sti";
    x.indexOf(y);               // returns 0
    x.indexOf(y, 1);            // returns 10
    x.indexOf(y, 10);           // returns 10
    x.indexOf(y, 11);           // returns -1
    1
    2
    3
    4
    5
    6
    (10)fill函数用于初始化字符串或给字符串赋值,将字符串中的每个字符设置为字符ch。如果字符串大小与(默认)不同,那么字符串就会预先调整大小。


    QString str = "Berlin";
    str.fill('z');
    // str == "zzzzzz"


    str.fill('A', 2);
    // str == "AA"
    1
    2
    3
    4
    5
    6
    (11) insert函数用于在给定的索引位置插入字符串str,并返回对该字符串的引用。


    QString str = "Meal";
    str.insert(1, QString("ontr"));
    // str == "Montreal"
    1
    2
    3
    (12) isEmpty函数用于判断字符串是否为空,并返回判断结果


    QString().isEmpty();            // returns true
    QString("").isEmpty();          // returns true
    QString("x").isEmpty();         // returns false
    QString("abc").isEmpty();       // returns false 
    1
    2
    3
    4
    (13) isNull效果和 isEmpty类似,如果该字符串为空,则返回true;否则返回false。


    QString().isNull();             // returns true
    QString("").isNull();           // returns false
    QString("abc").isNull();        // returns false 
    1
    2
    3
    (14)length函数返回该字符串中的字符数。相当于size()。 
    (15)resize(size)函数用于将字符串的大小设置为size大小。 
    如果字符串长度大于当前长度,则将字符串扩展为size长度长,并将额外的字符添加到末尾,新字符未初始化。 
    如果大小小于当前大小,则从末尾删除字符。


    QString s = "Hello world";
    s.resize(5);
    // s == "Hello"


    s.resize(8);
    // s == "Hello???" ,?代表任何字符
    1
    2
    3
    4
    5
    6
    (16)mid(int position, int n = -1)函数用于返回一个字符串,如果目标字符串包含从指定的位置索引开始的n个字符,则返回指定位置开始的由n个字符组成的字符串;如果位置索引超过了字符串的长度,则返回空字符串;如果从给定位置开始的字符串中有少于n个字符,或者如果n是-1(默认),函数将返回指定位置可用的所有字符。


    QString x = "Nine pineapples";
    QString y = x.mid(5, 4);            // y == "pine"
    QString z = x.mid(5);               // z == "pineapples"
    1
    2
    3
    (17)prepend(const QString & str)函数将字符串str预先设置为该字符串的开头,并返回对该字符串的引用。


    QString x = "ship";
    QString y = "air";
    x.prepend(y);
    // x == "airship"
    1
    2
    3
    4
    (18)remove(int position, int n)函数用于从字符串中移除n个字符,从给定的位置开始,并返回对字符串的引用。 
    如果指定的位置索引在字符串中,但是position + n位于字符串的末尾,那么字符串将在指定位置被截断。


    QString s = "Montreal";
    s.remove(1, 4);
    // s == "Meal"
    1
    2
    3
    (19)​replace(int position, int n, const QString & after)函数,用字符串替换从索引位置开始的n个字符,并返回对该字符串的引用。 
    注意:如果指定的位置索引在字符串中,但是position + n超出了字符串范围,那么n将会被调整到在字符串的末尾停止。


    QString x = "Say yes!";
    QString y = "no";
    x.replace(4, 3, y);
    // x == "Say no!"
    1
    2
    3
    4
    (20)setNum(int n, int base = 10)函数,将字符串设置为指定的打印值,并返回对字符串的引用。 
    默认值为10,必须在2到36之间。对于10以外的值,n被视为无符号整数。


    QString str;
    str.setNum(1234);       // str == "1234"
    1
    2
    (21)转换,相信这些很好理解


    double  toDouble(bool * ok = 0) const
    float   toFloat(bool * ok = 0) const
    int toInt(bool * ok = 0, int base = 10) const
    QByteArray  toLatin1() const
    QByteArray  toLocal8Bit() const
    long    toLong(bool * ok = 0, int base = 10) const
    qlonglong   toLongLong(bool * ok = 0, int base = 10) const
    QString toLower() const
    NSString *  toNSString() const
    short   toShort(bool * ok = 0, int base = 10) const
    std::string toStdString() const
    std::wstring    toStdWString() const
    uint    toUInt(bool * ok = 0, int base = 10) const
    ulong   toULong(bool * ok = 0, int base = 10) const
    qulonglong  toULongLong(bool * ok = 0, int base = 10) const
    ushort  toUShort(bool * ok = 0, int base = 10) const
    QVector<uint>   toUcs4() const
    QString toUpper() const
    QByteArray  toUtf8() const
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    (22)QString与QDateTime的相互转换 
    1、QDateTime转为QString


    QString str;  
    QDateTime time;  


    time = QDateTime::currentDateTime();  


    str = time.toString("yyyy-MM-dd hh:mm:ss");  
    1
    2
    3
    4
    5
    6
    2、QString转为QDateTime


    QString str;  
    QDateTime time;  


    str = "2018-04-02 13:35:00";  


    time = QDateTime::fromString(str, "yyyy-MM-dd hh:mm:ss");  
    1
    2
    3
    4
    5
    6
    版权声明:本文为博主原创文章,转载请注明出处。 https://blog.csdn.net/qq_40194498/article/details/79629632
    文章标签: QString
    个人分类: QT
    所属专栏: Qt之路
    相关热词: QString( QString QSTRING QString、 qstring
    更多相关内容
  • QString 字符串被每个GUI程序所使用,不仅是用户界面,还有数据结构。 C++原生提供两种字符串: 传统的C风格以’\0’结尾的字符数组和std::string类。与这些不同,QString使用16-bit Unicode值 当使用QString时,...
  • 一、QString赋值给char*  例如: QString qstr;  char *str = qstr.toLatin1().data();//这样便把qstr中的值传给了str 二 、char [] 赋值给string  char str[32];  string str2(str);//这样便把str中的值传给...
  • 介绍QString使用正则操作的接口。 Qt 5.0引入QRegularExpression,相比于QRegExp,前者修复了很多bugs,功能上也是兼容于QRegExp。推荐使用QRegularExpression。 contains 正则表达式rx是否与字符串中的某个地方...
  • QString转ASCII

    2020-11-20 17:42:59
    将 char Buff[]数组中的数据转换成QString数据,例如:将0x41转换“A”,就是将Char转成ASCII所对应的字母
  • 在Qt下写串口字符串读写方面的程序,里面需要处理一些QString和字符数组等方面的字符处理。 QStringQString类提供Unicode字符串。 QString存储一个16位QChars字符串,其中每个QChar对应一个Unicode 4.0字符。...
  • 主要介绍了Qt基础开发之QString与QByteArray详细用法与区别及QString QByteArray互转,需要的朋友可以参考下
  • QT将表格中的数据读取出来(QString),在使用QString 转换成对应的ASCII值(char)用于再在数组中传输 :例如:“A” 转换成 int或者char
  • 此为QString无损转char*和unsigned char* 。 当QString内容包含汉字时,转换char*等会发生失败。此接口解决了该问题。使用后char*与unsigned char*的qDebug()输出与QString输出结果相同。 注意,该函数返回unsigned ...
  • QString

    千次阅读 2018-09-03 05:28:05
    QString的类提供了一个Unicode字符串 头文件:QString QMAKE:QT +=core 成员列表  宏定义及枚举  构造函数  append  prepend  arg  asprintf  vasprintf  at  front  back  push_front ...

    QString的类提供了一个Unicode字符串
    头文件:QString
    QMAKE:QT +=core

    成员列表
     宏定义及枚举
     构造函数
     append
     prepend
     arg
     asprintf
     vasprintf
     at
     front
     back
     push_front
     push_back
     insert
     fill
     begin和constBegin
     rbegin
     end和constEnd
     rend
     cbegin,cend,crbegin和crend
     data和constData
     capacity
     chop和chopped
     size
     length
     resize
     reserve
     squeeze
     truncate
     shrink_to_fit
     swap
     clear
     isEmpty
     isNull
     isRightToLeft
     trimmed
     simplified
     repeated
     section
     remove
     replace
     number
     setNum
     count
     right,rightJustified和rightRef
     left,leftJustified和leftRef
     mid和midRef
     normalized
     indexOf
     lastIndexOf
     compare
     localeAwareCompare
     contains
     startsWith
     endsWith
     split
     splitRef
     unicode和utf16
     setRawData,setUnicode和setUtf16
     返回指定格式的QString
     转换为其他格式
     转换为基础数据类型的函数
     toUpper和toLower
    操作符重载


    成员列表

    嵌套类,枚举,宏定义

    class NULL;
    enum NormalizationForm;
    enum SectionFlag;
    enum SplitBehavior;
    flags SectionFlags;
    
    typedef ConstIterator;
    typedef const_iterator;
    typedef const_reverse_iterator;
    typedef const_pointer;
    typedef const_reference;
    typedef Iterator;
    typedef reverse_iterator;
    typedef pointer;
    typedef reference;
    
    typedef difference_type;
    typedef size_type;
    typedef value_type;
    
    const NULL null;
    

    构造函数,祈构函数

    QString();
    QString(const QChar *, int );
    QString(QChar );
    QString(int , QChar );
    QString(QLatin1String );
    QString(const QString &);
    QString(QString &&);
    QString(const char *);
    QString(const QByteArray &);
    ~QString();
    
    --------------公有成员函数-------------------
    

    将字符串追加到此字符串末尾

    QString& append(const QString &);
    QString& append(const QChar *, int );
    QString& append(QChar );
    QString& append(const QStringRef &);
    QString& append(QLatin1String );
    QString& append(const char *);
    QString& append(const QByteArray &);
    

    将字符串追加到此字符串开头

    QString& prepend(const QString &);
    QString& prepend(const QChar *, int );
    QString& prepend(QChar );
    QString& prepend(const QStringRef &);
    QString& prepend(QLatin1String );
    QString& prepend(const char *);
    QString& prepend(const QByteArray &);
    

    ①将字符串中的%1,%2,… %99的数字用第一个参数代替
    ②第二个参数fieldWidth = 0,指定第一个参数应占用的最小空间量
    ③如果第一个参数占用空间小于fieldWidth,则用最后一个参数字符填充,默认为“”
    ④base参数表示进制数,默认为10
    ⑤precision参数指示第一个参数按指定的格式和精度进行格式化
    后面几个重载函数可以当成是2至n个arg函数组成的
    注:%1,%2,… %99最好按顺序,不然当数据为整数时会产生意料之外的结果

    QString arg(const QString &, int fieldWidth, QChar ) const;
    QString arg(qulonglong , int fieldWidth, int base, QChar ) const;
    QString arg(long , int fieldWidth, int base, QChar ) const;
    QString arg(ulong , int fieldWidth, int base, QChar ) const;
    QString arg(int , int fieldWidth, int base, QChar ) const;
    QString arg(uint , int fieldWidth, int base, QChar ) const;
    QString arg(short , int fieldWidth, int base, QChar ) const;
    QString arg(ushort , int fieldWidth, int base, QChar ) const;
    QString arg(double , int fieldWidth, char , int precision, QChar ) const;
    QString arg(char , int fieldWidth, QChar ) const;
    QString arg(QChar , int fieldWidth, QChar ) const;
    QString arg(qlonglong , int fieldWidth, int base, QChar ) const;
    QString arg(QStringView , int fieldWidth, QChar ) const;
    QString arg(QLatin1String , int fieldWidth, QChar ) const;
    QString arg(const QString &, const QString &) const;
    QString arg(const QString &, const QString &, const QString &) const;
    QString arg(const QString &, const QString &, const QString &, const QString &) const;
    QString arg(const QString &, const QString &, const QString &, const QString &, const QString &) const;
    QString arg(const QString &, const QString &, const QString &, const QString &, const QString &, const QString &) const;
    QString arg(const QString &, const QString &, const QString &, const QString &, const QString &, const QString &, const QString &) const;
    QString arg(const QString &, const QString &, const QString &, const QString &, const QString &, const QString &, const QString &, const QString &) const;
    QString arg(const QString &, const QString &, const QString &, const QString &, const QString &, const QString &, const QString &, const QString &, const QString &) const ;
    

    从格式字符串cformat和任意参数列表安全地构建格式化字符串

    QString asprintf(const char *cformat,...);
    

    asprintf的等效方法

    QString vasprintf(const char *, va_list );
    

    返回字符串中索引为i的字符,第一个值为0

    const QChar at(int i) const;
    

    返回字符串中第一个字符
    用于兼容STL
    注:在空字符串上调用会造成未定义的行为

    QChar front() const;
    QCharRef front();
    

    返回字符串中最后一个字符
    用于兼容STL
    注:在空字符串上调用会造成未定义的行为

    QChar back() const;
    QCharRef back();
    

    将给定的其他字符串附加到此字符串的开头。它相当于append,用于STL兼容性

    void push_front(const QString &);
    void push_front(QChar );
    

    将给定的其他字符串附加到此字符串的末尾。它相当于append,用于STL兼容性

    void push_back(const QString &);
    void push_back(QChar );
    

    将第二个参数插入到第一个参数的索引位置,返回此字符串的引用
    给定索引大于size() 则调用resize()扩展

    QString& insert(int , const QString &);
    QString& insert(int , const QChar *, int );//第三个参数指定第二个参数大小
    QString& insert(int , QChar );
    QString& insert(int , const QStringRef &);
    QString& insert(int , QLatin1String );
    QString& insert(int , const char *);
    QString& insert(int , const QByteArray &);
    

    将字符串用第一个参数填充满
    size=-1为默认大小,如果指定其他大小值,则会重构大小

    QString& fill(QChar , int size=-1) ;
    

    返回指向第一个字符的迭代器

    iterator begin();
    const_iterator begin() const;
    const_iterator constBegin() const;
    

    返回指向字符串最后一个子符的逆向迭代器

    reverse_iterator rbegin();
    const_reverse_iterator rbegin() const;
    

    返回指向字符串最后一个子符的后一个位置的迭代器

    iterator end();
    const_iterator end() const;
    const_iterator constEnd() const;
    

    返回指向第一个字符的前一个位置的逆向迭代器

    reverse_iterator rend();
    const_reverse_iterator rend();
    

    1.返回指向最后一个字符的后一个位置的const迭代器
    2.返回指向第一个字符的const迭代器
    3.返回指向最后一个字符的const逆向迭代器
    4.返回指向第一个字符的前一个位置的const逆向迭代器

    const_iterator cend() const;
    const_iterator cbegin() const;
    const_reverse_iterator crbegin() const;
    const_reverse_iterator crend() const;
    

    返回指向存储在QString的数据的指针,可用于访问字符串的字符
    注:只要字符串未被修改,指针就保持有效
    注:返回的字符串可能不会被\0终止,第一个data函数返回的数据始终为\0终止

    QChar* data();
    const QChar* data() const;
    const QChar* constData() const;
    

    返回可以存储在字符串中的最大字节数,而不强制重新分配

    int capacity() const;
    

    从字符串末尾删除n个字符,第一个改变自身,后一个不改变自身但返回改变后的值

    void chop(int n);
    QString chopped(int n) const;
    

    返回字符串的大小

    int size() const;
    

    返回此字符串中的字符数,相当于size()

    int length() const;
    

    将字符串的大小设置为size,如果size小于当前大小,则从末尾删除多余字符,如果size大于当前大小,则在末尾添加额外字符
    第二个函数用第二个参数填充多出的空间

    void resize(int size);
    void resize(int , QChar );
    

    重新分配内存,大小为size

    void reserve(int size);
    

    释放存储字符数据不需要的任何内存

    void squeeze();
    

    截断index处的字符串,即丢弃index后面的字符串

    void truncate(int index);
    

    此功能用于STL兼容性。它相当于squeeze

    void shrink_to_fit();
    

    交换字符串

    void swap(QString &);
    

    清空字符串的内容,并使其为null

    void clear();
    

    如果字符串为空,则返回true,否则返回false

    bool isEmpty() const;
    

    如果字符串为null,则返回true,否则返回false

    bool isNull() const;
    

    如果从左到右读取字符串,则返回true,否则返回false

    bool isRightToLeft() const;
    

    将字符串开头和结尾的空格删除
    与simplified()不同,trimmed()仅留下内部空白

    QString trimmed() const;
    

    将字符串开头和结尾的空格删除

    QString simplified() const;
    

    返回字符串n次重复副本

    QString repeated(int n) const;
    

    第一个参数为字符串中字符或子串
    第二个参数为第一个参数第start次出现的位置
    第三个参数为第一个参数结尾的位置,默认为整个字符串
    flags参数用来影响功能的行为,具体查看官方文档

    QString section(QChar , int start, int end=-1, SectionFlags flags = SectionDefault) const;
    QString section(const QString &, int , int , SectionFlags ) const;
    QString section(const QRegExp &, int , int , SectionFlags ) const;
    QString section(const QRegularExpression &, int , int , SectionFlags ) const;
    

    第一个函数为,以第一个参数为索引,从字符串中删除第二个参数个字符
    后续的则是删除该字符串中所有的第一个参数
    Qt :: CaseSensitivity,有两个值
    Qt::CaseInsensitive:比较区分大小写,默认值
    Qt::CaseSensitive:比较区不分大小写

    QString& remove(int , int ) ;
    QString& remove(QChar , Qt::CaseSensitivity ) ;
    QString& remove(const QString &, Qt::CaseSensitivity );
    QString& remove(const QRegExp &);
    QString& remove(const QRegularExpression &);
    

    前三个函数为以index为起点,用第三个参数代替后面的n个字符
    后序的函数为,将字符串中的第一个参数替换为第二个参数值
    Qt :: CaseSensitivity,有两个值
    Qt::CaseInsensitive:比较区分大小写,默认值
    Qt::CaseSensitive:比较区不分大小写

    QString& replace(int index, int n, const QString &);
    QString& replace(int index, int n, const QChar *, int );
    QString& replace(int index, int n, QChar );
    QString& replace(QChar , QChar , Qt::CaseSensitivity );
    QString& replace(const QChar *, int , const QChar *, int , Qt::CaseSensitivity );
    QString& replace(QLatin1String , QLatin1String , Qt::CaseSensitivity );
    QString& replace(QLatin1String , const QString &, Qt::CaseSensitivity );
    QString& replace(const QString &, QLatin1String , Qt::CaseSensitivity );
    QString& replace(const QString &, const QString &, Qt::CaseSensitivity );
    QString& replace(QChar , const QString &, Qt::CaseSensitivity );
    QString& replace(QChar , QLatin1String , Qt::CaseSensitivity );
    QString& replace(const QRegExp &, const QString &);
    QString& replace(const QRegularExpression &, const QString &);
    

    该函数为静态成员函数
    根据给定的二进制,返回等于数字n的字符串
    format为双精度数的格式,具体查看参数格式

    QString number(long n, int base);
    QString number(uint n, int base);
    QString number(int n, int base);
    QString number(ulong n, int base);
    QString number(qlonglong n, int base);
    QString number(qulonglong n, int base);
    QString number(double n, char format ='g', int base);
    

    将字符串设置为给定进制数的数字
    最后两个函数的第二个参数为格式,查看官方文档
    最后两个函数的第三个参数为精度

    QString& setNum(int , int base=10);
    QString& setNum(ushort , int );
    QString& setNum(short , int );
    QString& setNum(uint , int );
    QString& setNum(long , int );
    QString& setNum(ulong , int );
    QString& setNum(qlonglong , int );
    QString& setNum(qulonglong , int );
    QString& setNum(float , char , int );
    QString& setNum(double , char , int );
    

    返回第一个参数在字符串中出现的个数
    Qt :: CaseSensitivity,有两个值
    Qt::CaseInsensitive:比较区分大小写,默认值
    Qt::CaseSensitive:比较区不分大小写

    int count(const QString &, Qt::CaseSensitivity ) const;
    int count(QChar , Qt::CaseSensitivity ) const;
    int count() const;//等同于size();
    int count(const QStringRef &, Qt::CaseSensitivity ) const;
    int count(const QRegExp &) const;
    int count(const QRegularExpression &) const;
    

    返回最右侧大小为n的子串,如果n大于等于size或为负数,则返回整个字符串
    当n大于size()时用fill填充
    truncate,为true且size大于n,则删除n之后的字符,为false则返回大小为n的字符串

    QString right(int n) const;
    QString rightJustified(int n, QChar fill, bool truncate=false) const;
    QStringRef rightRef(int n) const;
    

    返回最左侧大小为n的子串,如果n大于等于size或为负数,则返回整个字符串
    当n大于size()时用fill填充
    truncate,为true且size大于n,则删除n之后的字符,为false则返回大小为n的字符串

    QString left(int n) const;
    QString leftJustified(int n, QChar fill, bool truncate=false) const;
    QStringRef leftRef(int n) const;
    

    返回索引处开始大小为n的子串,如果n大于等于size或为负数,则返回整个字符串
    如果从指定位置开始的可用字符小于m或m=-1,返回指定位置后可用的所有字符

    QString mid(int n, int m=-1) const;
    QStringRef midRef(int n, int m=-1) const;
    

    根据给定的Unicode标准版本,返回给定Unicode规范化模式下的字符串
    NormalizationForm有四个
    QString::NormalizationForm_D:正则分解
    QString::NormalizationForm_C:正则分解与正则成分
    QString::NormalizationForm_KD:兼容性分解
    QString::NormalizationForm_KC:相容分解与规范组合
    QChar::UnicodeVersion=QChar :: Unicode_Unassigned默认值,具体查看官方文档

    QString normalized(NormalizationForm mode, QChar::UnicodeVersion ) const;
    

    返回第一个参数第一次在字符串中出现的索引位置,如果未找到,则返回-1
    第二个参数为索引位置起始点默认值为0,如果为-1则搜索从最后一个字符开始,-2则是倒二,类推
    Qt :: CaseSensitivity,有两个值
    Qt::CaseInsensitive:比较区分大小写,默认值
    Qt::CaseSensitive:比较区不分大小写

    int indexOf(const QString &, int , Qt::CaseSensitivity ) const;
    int indexOf(QChar , int , Qt::CaseSensitivity ) const;
    int indexOf(QLatin1String , int , Qt::CaseSensitivity ) const;
    int indexOf(const QStringRef &, int , Qt::CaseSensitivity ) const;
    int indexOf(const QRegExp &, int ) const;
    int indexOf(QRegExp &, int ) const;
    int indexOf(const QRegularExpression &, int ) const;
    int indexOf(const QRegularExpression &, int , QRegularExpressionMatch *) const;
    

    返回第一个参数最后一次在字符串中出现的索引位置,如果未找到,则返回-1
    第二个参数为索引位置起始点,默认值为-1,如果为-1则搜索从最后一个字符开始,-2则是倒二,类推
    Qt :: CaseSensitivity,有两个值
    Qt::CaseInsensitive:比较区分大小写,默认值
    Qt::CaseSensitive:比较区不分大小写

    int lastIndexOf(const QString &, int , Qt::CaseSensitivity ) const;
    int lastIndexOf(QChar , int , Qt::CaseSensitivity ) const;
    int lastIndexOf(QLatin1String , int , Qt::CaseSensitivity ) const;
    int lastIndexOf(const QStringRef &, int , Qt::CaseSensitivity ) const;
    int lastIndexOf(const QRegExp &, int ) const;
    int lastIndexOf(QRegExp &, int ) const;
    int lastIndexOf(const QRegularExpression &, int ) const;
    int lastIndexOf(const QRegularExpression &, int , QRegularExpressionMatch *) const;
    

    有三个参数的为静态成员函数,将s1和s2第一个不同的字符进行差法运算,返回差值
    有两个参数函数,将当前字符串与目标字符串进行比较,将第一个不同的字符进行差法运算,返回差值
    最后一个参数Qt :: CaseSensitivity,有两个值
    Qt::CaseInsensitive:比较区分大小写,默认值
    Qt::CaseSensitive:比较区不分大小写

    int compare(const QString &s1, const QString &s2, Qt::CaseSensitivity );
    int compare(QLatin1String , Qt::CaseSensitivity ) const;
    int compare(const QString &, Qt::CaseSensitivity ) const;
    int compare(const QString &, QLatin1String , Qt::CaseSensitivity );
    int compare(QLatin1String , const QString &, Qt::CaseSensitivity );
    int compare(const QStringRef &, Qt::CaseSensitivity ) const;
    int compare(const QString &, const QStringRef &, Qt::CaseSensitivity );
    

    l有两个参数的为静态成员函数,将s1和s2第一个不同的字符进行差法运算,返回差值
    有一个参数函数,将当前字符串与目标字符串进行比较,将第一个不同的字符进行差法运算,返回差值
    最后一个参数Qt :: CaseSensitivity,有两个值
    Qt::CaseInsensitive:比较区分大小写,默认值
    Qt::CaseSensitive:比较区不分大小写
    比较以平台相关进行

    int localeAwareCompare(const QString &, const QString &);
    int localeAwareCompare(const QString &) const;
    int localeAwareCompare(const QStringRef &) const;
    int localeAwareCompare(const QString &, const QStringRef &);
    

    如果字符串中含有第一个参数这个子串,则返回true,否则返回false
    最后一个参数Qt :: CaseSensitivity,有两个值
    Qt::CaseInsensitive:比较区分大小写,默认值
    Qt::CaseSensitive:比较区不分大小写

    bool contains(const QString &, Qt::CaseSensitivity ) const;
    bool contains(QChar , Qt::CaseSensitivity ) const;
    bool contains(QLatin1String , Qt::CaseSensitivity ) const;
    bool contains(const QStringRef &, Qt::CaseSensitivity ) const;
    bool contains(const QRegExp &) const;
    bool contains(QRegExp &) const;
    bool contains(const QRegularExpression &) const;
    bool contains(const QRegularExpression &, QRegularExpressionMatch *) const;
    

    如果字符串以第一个参数开头,则返回true,否则返回false
    Qt :: CaseSensitivity,有两个值
    Qt::CaseInsensitive:比较区分大小写,默认值
    Qt::CaseSensitive:比较区不分大小写

    bool startsWith(const QString &, Qt::CaseSensitivity ) const;
    bool startsWith(const QStringRef &, Qt::CaseSensitivity ) const ;
    bool startsWith(QStringView , Qt::CaseSensitivity ) const;
    bool startsWith(QLatin1String , Qt::CaseSensitivity ) const;
    bool startsWith(QChar , Qt::CaseSensitivity ) const;
    

    如果字符串以第一个参数结尾,则返回true,否则返回false
    Qt :: CaseSensitivity,有两个值
    Qt::CaseInsensitive:比较区分大小写,默认值
    Qt::CaseSensitive:比较区不分大小写

    bool endsWith(const QString &, Qt::CaseSensitivity ) const;
    bool endsWith(const QStringRef &, Qt::CaseSensitivity ) const;
    bool endsWith(QStringView , Qt::CaseSensitivity ) const ;
    bool endsWith(QLatin1String , Qt::CaseSensitivity ) const;
    bool endsWith(QChar , Qt::CaseSensitivity ) const;
    

    以第一个参数为分界字符,将字符串分为多个子串
    第二个参数为是否保留空串,默认为保存QString::KeepEmptyParts,QString::SkipEmptyParts
    Qt :: CaseSensitivity,有两个值
    Qt::CaseInsensitive:比较区分大小写,默认值
    Qt::CaseSensitive:比较区不分大小写

    QStringList split(const QString &, SplitBehavior , Qt::CaseSensitivity ) const;
    QStringList split(QChar , SplitBehavior , Qt::CaseSensitivity ) const;
    QStringList split(const QRegExp &, SplitBehavior ) const;
    QStringList split(const QRegularExpression &, SplitBehavior ) const;
    

    以第一个参数为分界字符,将字符串分为多个子串
    第二个参数为是否保留空串,默认为保存QString::KeepEmptyParts,QString::SkipEmptyParts
    Qt :: CaseSensitivity,有两个值
    Qt::CaseInsensitive:比较区分大小写,默认值
    Qt::CaseSensitive:比较区不分大小写

    QVector<QStringRef> splitRef(const QString &, SplitBehavior , Qt::CaseSensitivity ) const;
    QVector<QStringRef> splitRef(QChar , SplitBehavior , Qt::CaseSensitivity ) const;
    QVector<QStringRef> splitRef(const QRegExp &, SplitBehavior ) const;
    QVector<QStringRef> splitRef(const QRegularExpression &, SplitBehavior ) const;
    

    const QChar* unicode() const;
    const ushort* utf16() const;
    

    QString& setRawData(const QChar *, int );
    
    QString& setUnicode(const QChar *, int );
    
    QString& setUtf16(const ushort *, int );
    

    返回指定格式的QString串(静态成员函数)

    //构造一个包含字符串 CFString 副本的新QString,仅适用于OS X和iOS
    QString fromCFString(CFStringRef string);
    
    //1.返回使用Latin-1字符串str,大小为size的字符初始化的QString,size为str的长度,默认为整个字符串
    //2.返回使用Latin-1字符串str初始化的QString
    QString fromLatin1(const char *str, int size = -1 );
    QString fromLatin1(const QByteArray &str);
    
    //1.返回使用8位字符串str的大小为size的字符初始化的QString,size为str的长度,默认为整个字符串
    //2.返回使用8位字符串str初始化的QString
    QString fromLocal8Bit(const char *str, int size=-1 );
    QString fromLocal8Bit(const QByteArray &str);
    
    
    //构造一个包含字符串 NSString 副本的新QString,仅适用于OS X和iOS
    QString fromNSString(const NSString *string);
    
    //构造一个QString,使用数组unicode,大小为size。
    //使用该函数创建的字符串不是“\0”结尾,除非原始数据以“\0”结尾
    QString fromRawData(const QChar *unicode, int size);
    
    //用std::string创建一个QString副本
    QString fromStdString(const std::string &str);
    
    //用UTF-16编码的字符串创建一个QString副本
    QString fromStdU16String(const std::u16string &str);
    
    //用UTF-32编码的字符串创建一个QString副本
    QString fromStdU32String(const std::u32string &str);
    
    //用wstring(wchar_t组成)创建一个QString副本
    QString fromStdWString(const std::wstring &str);
    
    //用UCS-4编码的字符串创建一个QString副本
    QString fromUcs4(const uint *unicode, int size=-1);
    QString fromUcs4(const char32_t *str, int size=-1);
    
    //用UTF-8编码的字符串创建一个QString副本
    QString fromUtf8(const char *str, int size=-1);
    QString fromUtf8(const QByteArray &str);
    
    //用UTF-16编码的字符串创建一个QString副本
    QString fromUtf16(const ushort *unicode, int size=-1);
    QString fromUtf16(const char16_t *str, int size=-1);
    
    //用wchar_t字符串指针创建一个QString副本
    QString fromWCharArray(const wchar_t *str, int size=-1);
    

    //QString转换为CFString
    CFStringRef toCFString() const;
    
    //返回折叠等效字符串的大小写。对于大多数Unicode字符,与toLower相同
    QString toCaseFolded() const;
    
    //从QString创建NSString 。NSString是自动释放的。此功能仅适用于OS X和iOS
    NSString* toNSString() const;
    
    //一个纯文本字符串转换为HTML字符串HTML元字符<,>,&,并"通过HTML实体取代
    QString toHtmlEscaped() const;
    
    //返回类型为Latin-1的QByteArray
    QByteArray toLatin1() const;
    
    //返回8位编码的QByteArray,一般用来存储中文
    QByteArray toLocal8Bit() const;
    
    //返回UTF-8编码的QByteArray
    QByteArray toUtf8() const;
    
    //使用此QString对象中包含的数据填充数组。该阵列在wchar_t为2字节宽的平台(例如windows)上以UTF-16编码,在wchar_t为4字节宽的平台(大多数Unix系统)上以UCS-4编码
    int toWCharArray(wchar_t *) const;
    
    //返回一个std :: string对象
    std::string toStdString() const;
    
    //返回一个std :: u16string对象
    std::u16string toStdU16String() const;
    
    //返回一个std :: u32string对象
    std::u32string toStdU32String() const;
    
    //返回一个std :: wstring对象
    std::wstring toStdWString() const;
    

    //转换为double
    double toDouble(bool *) const
    
    //转换为float
    float toFloat(bool *) const;
    
    //第二个参数指示以何种进制表示,默认10进制
    
    //转换为int
    int toInt(bool *, int ) const;
    
    //转换为short
    short toShort(bool *, int ) const;
    
    //转换为long
    long toLong(bool *, int ) const;
    
    //转换为long long
    qlonglong toLongLong(bool *, int ) const;
    
    //转换为uint
    uint toUInt(bool *, int ) const;
    
    //转换为ushort
    ushort toUShort(bool *, int ) const;
    
    //转换为ulong
    ulong toULong(bool *, int ) const;
    
    //转换为ulonglong
    qulonglong toULongLong(bool *, int ) const;
    
    //返回字符串的UCS-4 / UTF-32表示形式的QVector <uint>
    QVector<uint> toUcs4() const;
    

    //返回字符串的大写形式或小写形式
    QString toUpper() const;
    QString toLower() const;
    

    操作符重载

    bool operator!=(QLatin1String ) const;
    bool operator!=(const char *) const;
    bool operator!=(const QByteArray &) const;
    
    bool operator==(QLatin1String ) const;
    bool operator==(const char *) const;
    bool operator==(const QByteArray &) const;
    
    QString& operator+=(const QString &);
    QString& operator+=(QChar );
    QString& operator+=(const QStringRef &);
    QString& operator+=(QLatin1String );
    QString& operator+=(const char *);
    QString& operator+=(const QByteArray &);
    QString& operator+=(char );
    
    QString& operator=(const QString &);
    QString& operator=(QChar );
    QString& operator=(QLatin1String );
    QString& operator=(QString &&);
    QString& operator=(const char *);
    QString& operator=(const QByteArray &);
    QString& operator=(char );
    QString& operator=(const Null &);
    
    bool operator<(QLatin1String ) const;
    bool operator<(const char *) const;
    bool operator<(const QByteArray &) const;
    
    bool operator<=(QLatin1String ) const;
    bool operator<=(const char *) const;
    bool operator<=(const QByteArray &) const;
    
    
    bool operator>(QLatin1String ) const;
    bool operator>(const char *) const;
    bool operator>(const QByteArray &) const;
    
    bool operator>=(QLatin1String ) const;
    bool operator>=(const char *) const;
    bool operator>=(const QByteArray &) const;
    
    QCharRef operator[](int );
    const QChar operator[](int ) const;
    const QChar operator[](uint ) const;
    QCharRef operator[](uint );
    
    展开全文
  • VS调试QT类中的QString无法查看到变量值时,进行相关的配置即可实现变量值的查看: 下载**qt5.natvis**放置到路径: > Microsoft\VS2017\Enterprise\Common7\Packages\Debugger\Visualizers
  • qt video,从基础开始,第5部分,一共14部分,使用vs2015的addin作为教学工具,很不错的。
  • QString介绍

    千次阅读 2020-12-29 01:45:40
    QString stores a string of 16-bit QChars, where each QChar corresponds one Unicode 4.0 character.一、初始化QString字符串1)Char * 初始化QString str = "Hello";QString converts the const char * data into...

    QString stores a string of 16-bit QChars, where each QChar corresponds one Unicode 4.0 character.

    一、初始化QString字符串

    1)Char * 初始化

    QString str = "Hello";

    QString converts the const char * data into Unicode using the fromAscii() function.

    2)QChar[]数组初始化

    Cpp代码  

    static const QChar data[4] = { 0x0055, 0x006e, 0x10e3, 0x03a3 };

    QString str(data, 4);

    也可以这样

    Cpp代码  

    QRegExp pattern;

    static const QChar unicode[] = { 0x005A, 0x007F, 0x00A4, 0x0060,

    0x1009, 0x0020, 0x0020};

    int size = sizeof(unicode) / sizeof(QChar);

    QString str = QString::fromRawData(unicode, size);

    3)还可以通过risize()函数和每个QChar字符进行初始化

    Cpp代码  

    QString str;

    str.resize(4);

    str[0] = QChar('U');

    str[1] = QChar('n');

    str[2] = QChar(0x10e3);

    str[3] = QChar(0x03a3);

    通过at()函数进行每个字符读取

    Cpp代码  

    QString str;

    for (int i = 0; i 

    if (str.at(i) >= QChar('a') && str.at(i) <= QChar('f'))

    qDebug() <

    }

    二、QString的操作函数  后续慢慢更新

    Cpp代码  

    QString str = "and";

    str.prepend("rock ");     // str == "rock and"

    str.append(" roll");        // str == "rock and roll"

    str.replace(5, 3, "&");   // str == "rock & roll"

    QString x = "free";

    QString y = "dom";

    x.append(y);           // x == "freedom"

    x.insert(x.size(), y);//x == "freedom"

    QString str = "Meal";

    str.insert(1, QString("ontr"));

    // str == "Montreal"

    QString s = "Montreal";

    s.remove(1, 4);     // s == "Meal"  移除1-4字符

    QString str("LOGOUT\r\n");

    str.chop(2);          // str == "LOGOUT" 从字符串后面移除2字符

    QString str = "Vladivostok";

    str.truncate(4);     //  str == "Vlad" 到4截断字符

    QString s = "Hello world";

    s.resize(5);         // s == "Hello"

    s.resize(8);        // s == "Hello???" (where ? stands for any character)

    QString t = "Hello";

    t += QString(10, 'X');

    // t == "HelloXXXXXXXXXX"

    QString r = "Hello";

    r = r.leftJustified(10, ' ');

    // r == "Hello     "

    QString x = "Pineapple";

    QString y = x.left(4);      // y == "Pine"

    QString x = "Pineapple";

    QString y = x.right(5);      // y == "apple"

    QString str = "Pineapple";

    str = str.rightJustified(5, '.', true);    // str == "Pinea"

    QString str = "Bananas";

    str.endsWith("anas");         // returns true

    str.endsWith("pple");         // returns false

    QString str = "Berlin";

    str.fill('z');

    // str == "zzzzzz"

    str.fill('A', 2);

    // str == "AA"

    QString x = "sticky question";

    QString y = "sti";

    x.indexOf(y);               // returns 0

    x.indexOf(y, 1);            // returns 10

    x.indexOf(y, 10);           // returns 10

    x.indexOf(y, 11);           // returns -1

    QString x = "crazy azimuths";

    QString y = "az";

    x.lastIndexOf(y);           // returns 6

    x.lastIndexOf(y, 6);        // returns 6

    x.lastIndexOf(y, 5);        // returns 2

    x.lastIndexOf(y, 1);        // returns -1

    QString x = "Nine pineapples";

    QString y = x.mid(5, 4);            // y == "pine"

    QString z = x.mid(5);               // z == "pineapples"

    long a = 63;

    QString s = QString::number(a, 16);             // s == "3f"

    QString t = QString::number(a, 16).toUpper();     // t == "3F"

    QString s = "Montreal";

    s.remove(1, 4);

    // s == "Meal"

    QString t = "Ali Baba";

    t.remove(QChar('a'), Qt::CaseInsensitive);

    // t == "li Bb"

    QString x = "Say yes!";

    QString y = "no";

    x.replace(4, 3, y);

    // x == "Say no!"

    QString str = "colour behaviour flavour neighbour";

    str.replace(QString("ou"), QString("o"));

    // str == "color behavior flavor neighbor"

    QString str;

    //! [51]

    QString csv = "forename,middlename,surname,phone";

    QString path = "/usr/local/bin/myapp"; // First field is empty

    QString::SectionFlag flag = QString::SectionSkipEmpty;

    str = csv.section(',', 2, 2);   // str == "surname"

    str = path.section('/', 3, 4);  // str == "bin/myapp"

    str = path.section('/', 3, 3, flag); // str == "myapp"

    //字符串转换成整型

    QString str;

    str.setNum(1234);       // str == "1234"

    //字符串转成整型

    long a = 63;

    QString s = QString::number(a, 16);             // s == "3f"

    QString t = QString::number(a, 16).toUpper();     // t == "3F"

    QString str = "a,,b,c";

    QStringList list1 = str.split(",");

    // list1: [ "a", "", "b", "c" ]

    QStringList list2 = str.split(",", QString::SkipEmptyParts);

    // list2: [ "a", "b", "c" ]

    QString str = "  lots\t of\nwhitespace\r\n ";

    str = str.trimmed();

    // str == "lots\t of\nwhitespace"

    //判断字符串相等

    int x = QString::compare("aUtO", "AuTo", Qt::CaseInsensitive);  // x == 0

    int y = QString::compare("auto", "Car", Qt::CaseSensitive);     // y > 0

    int z = QString::compare("auto", "Car", Qt::CaseInsensitive);   // z 

    Qstring 转换char*问题!

    方法一:

    QString qstr("hello,word");

    const char * p = qstr.toLocal8Bit().data();

    方法二:

    const char *p = qstr.toStdString().data();

    //转换过来的是常量

    方法三:

    QString str="abc";

    char *ch;

    QByteArray ba = str.toLatin1()

    ch = ba.data();

    三、更有效的构造 String

    我们通常通过"+"连接多个子字符串,例如:

    QString foo;

    QString type = "long";

    foo->setText(QLatin1String("vector::iterator"));

    if (foo.startsWith("(" + type + ") 0x"))

    ...

    这种构造写法,没有任何错误,但是有一些隐藏的效率问题。从Qt4.6之后,我们就可以消除这些问题。

    首先,多次使用"+"意味着多次进行内存分配。当你连接n个子字符串的时候,如果n>2,就会有n-1次内存分配。

    其次,QLatin1String 并不在内存中保存它的长度,而是当你需要知道它的长度时候,直接调用qstrlen()函数。

    在Qt4.6中,新建了一个内部模板类QStringBuilder ,它有一些可以帮助解决该问题的方法。这个类被当做内部的,并不出现在我们的帮助文档中,因为你的代码中并不会用到它。它的使用将会自动的,下面详细说一下。

    QStringBuilder  使用表达式模板重新解释'%'操作符,这样当你使用'%'代替'+'符号,连接字符串的时候,多次连接子字符串将被推迟,直到最后整个字符串被确定。这个时候,这个字符串的大小就是已知的了。这个时候内存分配器,就会一次性的分配这个已知大小的空间,然后把各个子字符串一个个拷贝进来。

    QLatin1Literal 是一个二级的内部类,它可以代替QLatin1String类。QLatin1String类因为兼容性的原因无法被改变。QLatin1Literal 存储了它的长度,因此当QStringBuilder 计算最后的字符串的大小时,可以节省时间。

    另外还通过内联潜入和减少引用次数(通过QStringBuilder 创立的QString,引用数是1,而QString::append()需要额外的测试)提高效率。

    有三种方式,可以使用这种改善string构造效率的方法。

    直接方式就是包含QStringBuilder ,当你在任何地方用到它的时候。然后当连接字符串的时候,用'%'代替'+'。

    #include

    QString hello("hello");

    QStringRef el(&hello, 2, 3);

    QLatin1String world("world");

    QString message =  hello % el % world % QChar('!');

    另外一种:全局的方式,定义一个宏定义。然后用用'%'代替'+'

    //使用快速连接

    #define QT_USE_FAST_CONCATENATION

    and use '%' instead of '+' for string concatenation everywhere.

    第三种方式:最方便,但是并不是所有代码都会兼容。就是包含两个宏定义即可。

    #define QT_USE_FAST_CONCATENATION

    #define QT_USE_FAST_OPERATOR_PLUS

    然后所有的'+'就会被当做QStringBuilder 的'%'执行。

    但在Qt 4.8、5.0,这个宏已被新的QT_USE_QSTRINGBUILDER宏所替代。(只需要这一个宏,就可以自动把'+'当做'%'执行)

    展开全文
  • Qt 对QString操作

    千次阅读 2020-12-29 01:45:33
    本帖最后由 kylin_try 于 2014-4-2 19:58 编辑QString QString::number ( ulong n, int base = 10 ) [静态]这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。也可以参考setNum()。QString ...

    本帖最后由 kylin_try 于 2014-4-2 19:58 编辑

    QString QString::number ( ulong n, int base = 10 ) [静态]

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    也可以参考setNum()。

    QString QString::number ( int n, int base = 10 ) [静态]

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    也可以参考setNum()。

    QString QString::number ( uint n, int base = 10 ) [静态]

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    一个把数字n转换为字符串表示的方便制造函数,n被基于base表示,默认为10,并且必须在2到36之间。

    也可以参考setNum()。

    QString QString::number ( double n, char f = 'g', int prec = 6 ) [静态]

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    根据fmt指定的格式,参数n被格式化,g为默认情况并且可以为下列之一:

    e - 格式化为[-]9.9e[+|-]999

    E - 格式化为[-]9.9E[+|-]999

    f - 格式化为[-]9.9

    g - 使用e或f格式,看哪一个更简练

    G - 使用E或f格式,看哪一个更简练

    在所有的情况下,小数点之后数字的个数等于prec指定的精度。

    double d = 12.34;

    QString ds = QString( "'E' format, precision 3, gives %1" )

    .arg( d, 0, 'E', 3 );

    // ds == "1.234E+001"

    也可以参考setNum()。

    QString::operator const char * () const

    返回latin1()。请确定已经看到这里的警告文档。注意对于你希望严格遵守Unicode的新代码,当你编译你的代码时,你可以定义QT_NO_ASCII_CAST宏来隐藏这个函数,这样自动抛出就不会被完成。这样可以添加你可以抓住在operator!()下描述的编程错误的优点。

    bool QString::operator! () const

    如果它不是零字符串,返回真,否则返回假。

    QString name = getName();

    if ( !name )

    name = "Rodney";

    注意如果你这样做

    QString name = getName();

    if ( name )

    doSomethingWith(name);

    它将调用“operator const char*()”,这是没有效率的,当你希望写遵守Unicode的代码时,你可以定义QT_NO_ASCII_CAST宏。

    当你想使用上述的语义时,请使用:

    QString name = getName();

    if ( !name.isNull() )

    doSomethingWith(name);

    QString & QString::operator+= ( const QString & str )

    把str添加到字符串中并且返回结果的引用。

    QString & QString::operator+= ( QChar c )

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    把字符c添加到字符串中并且返回结果的引用。

    QString & QString::operator+= ( char c )

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    把字符c添加到字符串中并且返回结果的引用。

    QString & QString::operator= ( QChar c )

    设置字符串只包含单个字符c。

    QString & QString::operator= ( const QString & s )

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    把s的一个浅度复制赋值给这个字符串并且返回这个字符串的引用。这是非常快的,因为字符串没有被实际复制。

    QString & QString::operator= ( const char * str )

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    把解释为经典C字符串的str的一个深度复制赋值给这个字符串并且返回这个字符串的引用。

    如果str为0,那么零字符串被创建。

    也可以参考isNull()。

    QString & QString::operator= ( const QCString & cs )

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    把解释为经典C字符串的cs的一个深度复制赋值给这个字符串并且返回这个字符串的引用。

    QString & QString::operator= ( char c )

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    设置字符串只包含单个字符c。

    QChar QString::operator[] ( int i ) const

    返回在索引i处的字符,或者如果i超过字符串的长度返回QChar::null。

    如果QString不是常量(也就是const QString)或者const&(也就是const QString&),那么operator[]的非常量重载将被使用来替代它。

    QCharRef QString::operator[] ( int i )

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    这个函数返回在索引i处的字符的引用。这个结果引用可以立即被赋值或者使用,但是一旦初始字符串发生了改变,它将会变为无效。

    如果i超过了字符串的长度,那么字符串将会被使用QChar::null来扩展,这样QCharRef就可以引用字符串中的有效(零)字符。

    QCharRef内部类可以被常量QChar使用,但是如果你对它赋值,你就会改变初始字符串(它将会自动分离,因为QString是写时复制)。如果你试图把结果作为QChar以外的东西使用,你将得到编译错误。

    QString & QString::prepend ( const QString & s )

    在字符串开始处插入s并且返回这个字符串的引用。

    等于insert(0, s)。

    QString string = "42";

    string.prepend( "The answer is " );

    // string == "The answer is 42"

    也可以参考insert()。

    QString & QString::prepend ( char ch )

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    在字符串开始处插入ch并且返回这个字符串的引用。

    等于insert(0, ch)。

    也可以参考insert()。

    QString & QString::prepend ( QChar ch )

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    在字符串开始处插入ch并且返回这个字符串的引用。

    等于insert(0, ch)。

    也可以参考insert()。

    QChar & QString::ref ( uint i )

    返回在索引i的QChar的引用,如果需要就是用QChar::null扩展字符串。这个结果引用可以立即被赋值或者使用,但是一旦初始字符串发生了改变,它将会变为无效。

    QString string("ABCDEF");

    QChar ch = string.ref( 3 );         // ch == 'D'

    也可以参考constref()。

    QString & QString::remove ( uint index, uint len )

    从字符串中的index位置开始移除len个字符并且返回这个字符串的引用。

    如果index超出字符串的长度,就什么也不发生。如果index在字符串中间,但是index加上len超过字符串的结尾,这个字符串将从index开始被截短。

    QString string( "Montreal" );

    string.remove( 1, 4 );      // string == "Meal"

    也可以参考insert()和replace()。

    QString & QString::replace ( uint index, uint len, const QString & s )

    从字符串中的index位置开始使用s替换len个字符,并且返回这个字符串的引用。

    如果index超出字符串的长度,就什么也不被删除并且s被添加到字符串结尾。如果 index有效并且index加上len超过字符串的结尾,那么这个字符串将从index开始被截短,并且s被添加到字符串结尾。

    QString string( "Say yes!" );

    string = string.replace( 4, 3, "NO" );

    // string == "Say NO!"

    也可以参考insert()和remove()。

    实例:listviews/listviews.cpp、network/networkprotocol/nntp.cpp和qmag/qmag.cpp。

    QString & QString::replace ( uint index, uint len, const QChar * s, uint slen )

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    从字符串中的index位置开始使用s中的slen个字符的QChar数据替换len个字符,并且返回这个字符串的引用。

    也可以参考insert()和remove()。

    QString & QString::replace ( const QRegExp & rx, const QString & str )

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    用str替换字符串中出现的每一个正则表达式rx。返回这个字符串的引用。

    QString string = "banana";

    string = string.replace( QRegExp("an"), "" ); // string == "ba"

    也可以参考find()和findRev()。

    QString QString::right ( uint len ) const

    返回包含字符串最右面的len个字符的子字符串。

    如果len超过字符串的长度,则整个字符串被返回。

    QString string( "Pineapple" );

    QString t = string.right( 5 );   // t == "apple"

    也可以参考left()、mid()和isEmpty()。

    实例:fileiconview/qfileiconview.cpp。

    QString QString::rightJustify ( uint width, QChar fill = ' ', bool truncate = FALSE ) const

    返回一个长度为width的,包含fill填补的字符串,后面跟着这个字符串。

    如果truncate为假并且字符串的长度超过width,那么返回的字符串是这个字符串的复制。

    如果truncate为真并且字符串的长度超过width,那么这个字符串的复制中超过width长度的任何字符都被移除并且这个复制被返回。

    QString string( "apple" );

    QString t = string.rightJustify( 8, '.' );  // t == "...apple"

    也可以参考leftJustify()。

    QString QString::section ( QChar sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const

    这个函数用来返回字符串的一部分。

    这个字符串被看作由字符sep分隔开的顺序的区段。返回的从位置start到位置end(两个都包含)的区段组成的字符串。如果end没有被指定,那么从位置start开始到字符串的结尾的所有区段都被返回。区段是从左面是0、1、2等等计数,或者从右面-1、-2等等计数的。

    flags参数可以用来影响这个函数行为的特征,例如是否区分大小写,是否忽略空区段并且如何处理开始和结尾的分隔符,请参考SectionFlags。

    QString csv( "forename,middlename,surname,phone" );

    QString s = csv.section( ',', 2, 2 );   // s == "surname"

    QString path( "/usr/local/bin/myapp" ); // First field is empty

    QString s = path.section( '/', 3, 4 );  // s == "bin/myapp"

    QString s = path.section( '/', 3, 3, SectionSkipEmpty ); // s == "myapp"

    如果start或者end为负数,我们就从字符串的右面开始计数,最右面的是-1,接着是-2,依此类推。

    QString csv( "forename,middlename,surname,phone" );

    QString s = csv.section( ',', -3, -2 );  // s == "middlename,surname"

    QString path( "/usr/local/bin/myapp" ); // First field is empty

    QString s = path.section( '/', -1 ); // s == "myapp"

    也可以参考QStringList::split()。

    实例:chart/element.cpp。

    QString QString::section ( char sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    QString QString::section ( const char * sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    QString QString::section ( const QString & sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    这个函数用来返回字符串的一部分。

    这个字符串被看作由字符串sep分隔开的顺序的区段。返回的从位置start到位置end(两个都包含)的区段组成的字符串。如果end没有被指定,那么从位置start开始到字符串的结尾的所有区段都被返回。区段是从左面是0、1、2等等计数,或者从右面-1、-2等等计数的。

    flags参数可以用来影响这个函数行为的特征,例如是否区分大小写,是否忽略空区段并且如何处理开始和结尾的分隔符,请参考SectionFlags。

    QString data( "forename**middlename**surname**phone" );

    QString s = data.section( "**", 2, 2 ); // s == "surname"

    如果start或者end为负数,我们就从字符串的右面开始计数,最右面的是-1,接着是-2,依此类推。

    QString data( "forename**middlename**surname**phone" );

    QString s = data.section( "**", -3, -2 ); // s == "middlename**surname"

    也可以参考QStringList::split()。

    QString QString::section ( const QRegExp & reg, int start, int end = 0xffffffff, int flags = SectionDefault ) const

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    这个函数用来返回字符串的一部分。

    这个字符串被看作由正则表达式reg分隔开的顺序的区段。返回的从位置start到位置end(两个都包含)的区段组成的字符串。如果end没有被指定,那么从位置start开始到字符串的结尾的所有区段都被返回。区段是从左面是0、1、2等等计数,或者从右面-1、-2等等计数的。

    flags参数可以用来影响这个函数行为的特征,例如是否区分大小写,是否忽略空区段并且如何处理开始和结尾的分隔符,请参考SectionFlags。

    QString line( "forename\tmiddlename  surname \t \t phone" );

    QRegExp sep( "\s+" );

    QString s = line.section( sep, 2, 2 ); // s == "surname"

    如果start或者end为负数,我们就从字符串的右面开始计数,最右面的是-1,接着是-2,依此类推。

    QString line( "forename\tmiddlename  surname \t \t phone" );

    QRegExp sep( "\\s+" );

    QString s = line.section( sep, -3, -2 ); // s == "middlename  surname"

    警告: QRegExp这一部分比其它字符串和字符的重载版本要花费更多。

    也可以参考QStringList::split()和simplifyWhiteSpace()。

    void QString::setExpand ( uint index, QChar c )

    这个函数是废弃的。它的提供只是为了保证旧代码能够工作。我们强烈建议在新代码中不要使用它。

    设置在index位置的字符为c并且如果需要使用空格来扩展这个字符串。

    这个方法在Qt 3.x中是多余的,因为operator[]可以在需要的时候扩展字符串。

    QString & QString::setLatin1 ( const char * str, int len = -1 )

    设置这个字符串为解释为经典的Latin1的C字符串的str。如果len为-1(默认),那么它将被设置为strlen(str)。

    如果str为0,那么零字符串被创建。如果str为“”,那么空字符串被创建。

    也可以参考isNull()和isEmpty()。

    void QString::setLength ( uint newLen )

    确保至少newLen个字符被分配给这个字符串,并且设置这个字符串的长度为newLen。任何分配的新空间保留任意的数据。

    如果newLen为0,那么这个字符串将变为空,除非这个字符串是零,这种情况下它仍保持为零。

    如果不能分配足够的内存,字符串保持不变。

    这个函数总是把这个字符串和有同样数据的其它引用分离。

    这个函数对于需要构建一个长字符创并且想避免重复重新分配空间的代码很有用。在这个实例中,我们想添加字符串,直到条件为真,并且我们十分确信分配给它的大小是足够大的:

    QString result;

    int resultLength = 0;

    result.setLength( newLen ) // 分配一些空间

    while ( ... ) {

    result[resultLength++] = ... // 填充(部分的)空格作为数据

    }

    result.truncate[resultLength]; // 并且去掉不确定的垃圾

    如果newLen是不足的话,最坏的情况就是将会循环将会变慢。

    也可以参考truncate()、isNull()、isEmpty()和length()。

    QString & QString::setNum ( long n, int base = 10 )

    设置字符串为打印的数据n,n是基于base并且返回这个字符串的引用。

    base默认为10并且必须在2到36之间。

    QString string;

    string = string.setNum( 1234 );     // string == "1234"

    QString & QString::setNum ( short n, int base = 10 )

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。设置字符串为打印的数据n,n是基于base并且返回这个字符串的引用。

    base默认为10并且必须在2到36之间。

    QString & QString::setNum ( ushort n, int base = 10 )

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。设置字符串为打印的数据n,n是基于base并且返回这个字符串的引用。

    base默认为10并且必须在2到36之间。

    QString & QString::setNum ( int n, int base = 10 )

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。设置字符串为打印的数据n,n是基于base并且返回这个字符串的引用。

    base默认为10并且必须在2到36之间。

    QString & QString::setNum ( uint n, int base = 10 )

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。设置字符串为打印的数据n,n是基于base并且返回这个字符串的引用。

    base默认为10并且必须在2到36之间。

    QString & QString::setNum ( ulong n, int base = 10 )

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。设置字符串为打印的数据n,n是基于base并且返回这个字符串的引用。

    base默认为10并且必须在2到36之间。

    QString & QString::setNum ( float n, char f = 'g', int prec = 6 )

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    设置字符串为打印的由格式f和精度prec格式化的数据n并且返回这个字符串的引用。

    格式f可以为“f”、“F”、“e”、“E”、“g”或者“G”。关于这些格式的解释请参考arg()。

    QString & QString::setNum ( double n, char f = 'g', int prec = 6 )

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    设置字符串为打印的由格式f和精度prec格式化的数据n并且返回这个字符串的引用。

    格式f可以为“f”、“F”、“e”、“E”、“g”或者“G”。关于这些格式的解释请参考arg()。

    QString & QString::setUnicode ( const QChar * unicode, uint len )

    重新定义字符串的大小为len并且把unicode复制到字符串中。如果unicode为零,什么都不被复制,但是字符串还是被重新定义为len。如果len为0,那么字符串变为零字符串。

    也可以参考setLatin1()和isNull()。

    QString & QString::setUnicodeCodes ( const ushort * unicode_as_ushorts, uint len )

    重新定义字符串的大小为len并且把unicode_as_ushorts复制到字符串中(在一些X11客户端平台上这将进入到二进制缓存通道中)。

    如果unicode_as_ushorts为零,什么都不被复制,但是字符串还是被重新定义为len。如果len为0,那么字符串变为零字符串。

    也可以参考setLatin1()和isNull()。

    QString QString::simplifyWhiteSpace () const

    返回一个移除了这个字符串的开始和结尾的空白符号的字符串,并且内部的空白符号都被替代为单一的空格。

    空白符号是指任何QChar::isSpace()返回真的字符。这里面包括十进制为9(TAB)、10(LF)、11(VT)、12(FF)、13(CR)和32(Space)的UNICODE字符。

    QString string = "  lots\t of\nwhite    space ";

    QString t = string.simplifyWhiteSpace();

    // t == "lots of white space"

    也可以参考stripWhiteSpace()。

    QString & QString::sprintf ( const char * cformat, ... )

    从一个格式化字符串cformat和一个任意的参数列表安全地构建一个格式化的字符串。

    %s转义序列希望一个utf8()编码字符串。格式化字符串cformat希望是一个Latin1的。如果你需要一个Unicode格式字符串,使用arg()来替代。为了完全支持Unicode的类型安全的字符串构建,你可以像这样使用QTextOStream:

    QString str;

    QString s = ...;

    int x = ...;

    QTextOStream( &str ) << s << " : " << x;

    对于翻译,特别是如果字符串包含超过一个的转义序列,你应该考虑使用arg()来替代它。这将允许翻译者来控制替换的顺序并且支持Unicode。

    也可以参考arg()。

    实例:dclock/dclock.cpp、forever/forever.cpp、layout/layout.cpp、qmag/qmag.cpp、scrollview/scrollview.cpp、tooltip/tooltip.cpp和xform/xform.cpp。

    bool QString::startsWith ( const QString & s ) const

    如果字符串以s开始,返回真,否则返回假。

    QString string("Bananas");

    bool a = string.startsWith("Ban");      //  a == TRUE

    也可以参考endsWith()。

    QString QString::stripWhiteSpace () const

    返回一个移除了这个字符串的开始和结尾的空白符号的字符串,并且内部的空白符号都被替代为单一的空格。

    空白符号是指任何QChar::isSpace()返回真的字符。这里面包括十进制为9(TAB)、10(LF)、11(VT)、12(FF)、13(CR)和32(Space)的UNICODE字符。

    QString string = "   white space   ";

    QString s = string.stripWhiteSpace();       // s == "white space"

    也可以参考simplifyWhiteSpace()。

    double QString::toDouble ( bool * ok = 0 ) const

    返回由这个字符串转化的double值。

    如果转化发生错误,*ok被设置为假(除非ok为0,这是默认的)并且0被返回。否则*ok被设置为真。

    QString string( "1234.56" );

    double a = string.toDouble();   // a == 1234.56

    也可以参考number()。

    float QString::toFloat ( bool * ok = 0 ) const

    返回由这个字符串转化的float值。

    如果转化发生错误,*ok被设置为假(除非ok为0,这是默认的)并且0被返回。否则*ok被设置为真。

    也可以参考number()。

    int QString::toInt ( bool * ok = 0, int base = 10 ) const

    返回由这个字符串转化的int值,是基于base的,默认为10并且必须在2到36之间。

    如果转化发生错误,*ok被设置为假(除非ok为0,这是默认的)并且0被返回。否则*ok被设置为真。

    QString str( "FF" );

    bool ok;

    int hex = str.toInt( &ok, 16 );     // hex == 255, ok == TRUE

    int dec = str.toInt( &ok, 10 );     // dec == 0, ok == FALSE

    也可以参考number()。

    long QString::toLong ( bool * ok = 0, int base = 10 ) const

    返回由这个字符串转化的long值,是基于base的,默认为10并且必须在2到36之间。

    如果转化发生错误,*ok被设置为假(除非ok为0,这是默认的)并且0被返回。否则*ok被设置为真。

    也可以参考number()。

    short QString::toShort ( bool * ok = 0, int base = 10 ) const

    返回由这个字符串转化的short值,是基于base的,默认为10并且必须在2到36之间。

    如果转化发生错误,*ok被设置为假(除非ok为0,这是默认的)并且0被返回。否则*ok被设置为真。

    uint QString::toUInt ( bool * ok = 0, int base = 10 ) const

    返回由这个字符串转化的unsigned int值,是基于base的,默认为10并且必须在2到36之间。

    如果转化发生错误,*ok被设置为假(除非ok为0,这是默认的)并且0被返回。否则*ok被设置为真。

    也可以参考number()。

    ulong QString::toULong ( bool * ok = 0, int base = 10 ) const

    返回由这个字符串转化的unsigned long值,是基于base的,默认为10并且必须在2到36之间。

    如果转化发生错误,*ok被设置为假(除非ok为0,这是默认的)并且0被返回。否则*ok被设置为真。

    也可以参考number()。

    ushort QString::toUShort ( bool * ok = 0, int base = 10 ) const

    返回由这个字符串转化的unsigned short值,是基于base的,默认为10并且必须在2到36之间。

    如果转化发生错误,*ok被设置为假(除非ok为0,这是默认的)并且0被返回。否则*ok被设置为真。

    void QString::truncate ( uint newLen )

    如果newLen小于字符串的长度,那么字符串将从newLen位置被截短。否则就什么也不发生。

    QString s = "truncate me";

    s.truncate( 5 );            // s == "trunc"

    也可以参考setLength()。

    实例:network/mail/smtp.cpp。

    const QChar * QString::unicode () const

    返回这个字符串的Unicode表述。直到这个字符串被修改,这个结果保持有效。

    QString QString::upper () const

    返回由这个字符串转换的大写字符串。

    QString string( "TeXt" );

    str = string.upper();     // t == "TEXT"

    也可以参考lower()。

    实例:scribble/scribble.cpp和sql/overview/custom1/main.cpp。

    展开全文
  • 文章目录1、QString常用转换1.1、QString转(int、float、double)1.2、(int,float,double)转(QString)1.3、const char* 转QString1.4、 QString 转 QByteArray 转const char*1.5、QString 转QDateTime1.6、...
  • QString详细使用说明 QString字符编码 QString字符转换 Qt字符串使用 Qt高效构造字符串
  • QT中QString的用法总结

    千次阅读 2021-05-14 10:46:18
    QT经常使用过程中难免会涉及到各种字符类的转换,如MFC中的CString,C++标准类的string以及QT中的QString。每个类都有自己的用法,今天主要总结QT中特有的QString使用方法。 1、QString的基本用法 1. 将一个字符串...
  • QString总结

    千次阅读 2020-12-31 06:11:58
    QString存储字符串采用的是Unicode码,每一个字符是一个十六位的QChar, 而不是八位的char, 所以处理中文字符没有问题, 而且一个汉字是一个字符。1、append()和prepend()append()在字符串后面添加字符串,prepend()在...
  • QString//QString定义QString s1 = "abc";QString s2("hello");//字符串连接QString s = s1 + s2;//组包s = QString("a = %1, b = %2, c = %3").arg(250).arg("hello").arg(22.22);qDebug()<//输出结果:a = 250, ...
  • QT QStringList 与 QString 常用方法

    千次阅读 2020-05-25 15:18:18
    本文汇集了QString 与 (QStringList | QByteArray)之间的转换,以及QStringQStringList的一些常用方法。
  • Qt5 之QString类的使用

    2021-03-30 22:04:17
    QString 是Qt编程中常用的类,除了用作数字量的输入输出之外,QString 还有很多其他功能,熟悉这些常见的功能,有助于灵活地实现字符串处理功能。 QString 存储字符串釆用的是 Unicode 码,每一个字符是一个 16 位...
  • QStringQStringList

    2021-09-13 10:07:21
    一、QString C++ 原生提供两种字符串 (1)传统的以“\0”结尾的字符数组; (2)std::string类 与C++原生提供两种字符串不同,QString使用的是16bit Unicode的值。 Unicode包含了ASCII 和 Latin-1; Tip :...
  • Qt中QString中文乱码

    千次阅读 2022-05-30 10:54:16
    首先呢,声明一下,QString 是不存在中文支持问题的,很多人遇到问题,并不是本身 QString 的问题,而是没有将自己希望的字符串正确赋给QString。 很简单的问题,"我是中文"这样写的时候,它是传统的 char 类型的窄...
  • Qt QString使用

    2022-04-06 17:30:16
    QString常用方法
  • C++ Qt QString转string乱码的处理方法

    千次阅读 2021-12-16 21:35:53
    QString在转string时,如果有中文,会出现乱码,例如下面的代码 #include <QCoreApplication> #include <QDebug> #include <string> #include <iostream> using namespace std; int main...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 102,151
精华内容 40,860
关键字:

qstring