精华内容
下载资源
问答
  • 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 );
    
    展开全文
  • Qstring

    千次阅读 2018-07-12 10:57:35
    原地址:https://blog.csdn.net/qq_40194498/article/details/79629632QString在Qt的各种数据转换中可谓举足轻重,熟悉QString的用法对于Qt编程真的是如虎添翼:QString 字符串有相当多的操作符和函数,此处只介绍...

    原地址: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

    千次阅读 2010-10-30 21:17:00
    所有的QString的方法都使用const char *参数,const char *被解释为经典的C风格的以零结尾的ASCII字符串。所以const char *参数为0是合法的。如果const char *不是以零结尾的,结果是不确定的。把经典的C字符...

    所有的QString的方法都使用const char *参数,const char *被解释为经典的C风格的以零结尾的ASCII字符串。所以const char *参数为0是合法的。如果const char *不是以零结尾的,结果是不确定的。把经典的C字符串复制到QString的函数将不会复制结尾的0字符。QString的QChar数组(可以通过unicode()返回)通常不以零结尾。如果你需要把QString传递到一个需要C的以零结尾的字符串,请使用latin1()。

    QString::null是一个零QString。当排序的时候,空字符串在最前面,然后是非空字符串,然后才是零字符串。我们建议使用if ( !str.isNull() ),而不是if ( !str )来检测非零字符串,关于解释说明也可以参考operator!()。

    注意如果你发现你正在混合使用QCString、QString和QByteArray,这将会导致很多不必要的复制并且也许会预示着你正在处理的真实自然数据是不确定的。如果数据是以零结尾的八位数据,请使用QCString;如果它是没有结尾的(也就是包含0)八位数据,请使用QByteArray;如果它是文本,请使用QString。

    字符串列表可以使用QStringList类来处理。你可以使用QStringList::split()来把一个字符串分割为一个字符串列表,并且可以使用QStringList::join()把一个字符串列表连接成一个使用随意间隔符的字符串。你也可以使用QStringList::grep()从一个字符串列表中获得包含特定子字符串或者包含匹配特定的regex的字符串列表。

    C程序员的注意事项

    由于C++的类型系统和QString是隐含共享的事实,QString也许会被看做整型或者其它简单基本类型。例如:

    QString boolToString( bool b ) { QString result; if ( b ) result = "True"; else result = "False"; return result; }

    变量result是一个分配在栈中的自动变量。当return被调用时,因为我们正在返回值,复制构造函数被调用并且这个字符串的一个复制被返回。(我们要感谢隐含共享,没有实际的复制发生,请看下面。)

    在Qt的源代码中,你将会遇到想这样的QString的用法:

    QString func( const QString& input ) { QString output = input; // 处理输出 return output; }

    从input到output的“复制”几乎和复制指针一样快,因为后面的场景复制是通过增加引用计数器来实现的。QString操作是基于写时复制的,只有在实例发生实际改变时,才会被复制。

    如果你想不丢失任何Unicode信息的情况下创建一个QString的深度复制,那么你应该使用QString中用QChar*作为参数的构造函数。例如:

    QString a("abcd"); QString b( a.unicode(), b.length() );

    另外,使用QString中用const char*参数的构造函数就足够了。例如:

    QString a("abcd"); QString b( a.latin1() );

    也可以参考QCharQCStringQByteArrayQConstString隐含和明显共享类文本相关类非图形用户界面类


     

    成员类型文档

    section()。


     

    成员函数文档

    isNull()。

    QChar ch )

    构造一个长度为一个字符,内容为给定字符ch的字符串。

    QString & s )

    构造一个s的隐含共享的复制。这是短时间的,因为引用计数被使用。

    QByteArray & ba )

    构造一个被解释为经典C字符串的ba的深度复制的字符串。

    QChar * unicode, uint length )

    构造一个QChar数组中开始length个字符的深度复制的字符串。

    如果unicode和length为0,那么一个零字符串被创建。

    如果只是unicode为0,字符串为空,但是被分配为length个字符空间——无论如何QString可以自动扩展,但是这也许会在一些情况下提高速度。我们建议根据这个目的使用简单的构造函数和setLength(),因为它的结果是有更多的可读代码。

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

    深度复制的字符串。

    如果str,那么一个零字符串被创建。

    这是一个抛出构造函数,但是它是完全安全的:把一个Latin1的const char*转化到QString保存了所有的信息。当你编译你的应用程序时,你可以通过定义QT_NO_CAST_ASCII来关闭这个构造函数。你可以使用setLatin1()、fromLatin1()、fromLocal8Bit()和fromUtf8()来生成QString。或者无论什么适合你的八位数据的编码方式。

    也可以参考isNull()。

    QString & QString & str )

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

    string = "Test"; string.append( "ing" ); // string == "Testing"

    等于operator+=()。

    实例:dirview/dirview.cpp

    QString & operator+=()。

    QString & QChar ch )

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

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

    等于operator+=()。

    QString QString & a, int fieldwidth = 0 ) const

    这个函数将返回使用a来替换最低层出现的%ii为'1'或'2'或……'9')的字符串。

    fieldwidth值指定了填充到a中的最小空间。正值将产生右对齐文本,负值将产生左对齐文本。

    QString firstName( "Joe" ); QString lastName( "Bloggs" ); QString fullName; fullName = QString( "First name is '%1', last name is '%2'" ) .arg( firstName ) .arg( lastName ); // fullName == First name is 'Joe', last name is 'Bloggs'

    警告:如果你是用arg()来构造一个想上面实例中的“真正”的句子,那么这可能导致一些翻译的问题(当你使用tr()函数时)。

    如果没有%i模式,一个警告信息(qWarning())被输出并且这个文本被添加到字符串的末尾。这被做为错误恢复的功能并且不应该在正确的代码中出现。

    也可以参考QObject::tr()。

    QString QString( "Decimal 63 is %1 in hexadecimal" ) .arg( 63, 0, 16 ); // str == "Decimal 63 is 3f in hexadecimal"

    QString QString QString QString QString QString QString QChar a, int fieldwidth = 0 ) const

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

    QString QString( "'E' format, precision 3, gives %1" ) .arg( d, 0, 'E', 3 ); // ds == "1.234E+001"

    const char * latin1()并且返回结果。

    实例:network/networkprotocol/nntp.cpp

    QChar QChar ch = string.at( 4 ); // ch == 'e'

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

    QCharRef QString & s1, const QString & s2 ) [静态]

    对s1和s2进行词典比较,如果s1小于、等于或者大于s2,就返回小于、等于或者大于0的整数。

    这个比较是专有的基于字符的数字Unicode值并且非常快,但是不是人们所期待的。排序用户界面字符串请考虑使用QString::localeAwareCompare()。

    int a = QString::compare( "def", "abc" ); // a > 0 int b = QString::compare( "abc", "def" ); // b < 0 int c = QString::compare(" abc", "abc" ); // c == 0

    int QString & s ) const

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

    对这个字符串和s进行词典比较,如果它小于、等于或者大于s,就返回小于、等于或者大于0的整数。

    void QChar(0x0041)('A')和QChar(0x0308)(Unicode accent diaresis),给定的QChar(0x00c4)(德语的A元音变音)。

    QChar QChar的值。

    等于at(i)。

    也可以参考ref()。

    int QChar c, bool cs = TRUE ) const

    返回在这个字符串中字符c出现的次数。

    如果cs为真,那么匹配是区分大小写的。如果cs为假,那么匹配是不区分大小写的。

    QString string( "Trolltech and Qt" ); int i = string.contains( 't', FALSE ); // i == 3

    实例:fileiconview/qfileiconview.cppmdi/application.cpp

    int QString & str, bool cs = TRUE ) const

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

    返回在这个字符串中str出现的次数。

    如果cs为真,那么匹配是区分大小写的。如果cs为假,那么匹配是不区分大小写的。

    这个函数计算重叠的字符串,所以在下面的实例中,“bananas”中有两个“ana”的实例。

    QString str( "bananas" ); int i = str.contains( "ana" ); // i == 2

    也可以参考findRev()。

    int QRegExp & rx ) const

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

    返回在字符串中正则表达式rx出现的次数。

    这个函数计算重叠的字符串,所以在下面的实例中,有四个“ana”或者“ama”的实例。

    QString str = "banana and panama"; QRegExp rxp = QRegExp( "a[nm]a", TRUE, FALSE ); int i = str.contains( rxp ); // i == 4

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

    QString QString & s ) const

    如果字符串以s结尾,返回真,否则返回假。

    也可以参考startsWith()。

    实例:chart/main.cpp

    QString & QChar c, int len = -1 )

    填充字符串为len个字符的值c,并且返回字符串的引用。

    如果len为负数(默认),当前字符串长度被使用。

    QString str; str.fill( 'g', 5 ); // string == "ggggg"

    int QRegExp & rx, int index = 0 ) const

    从位置index开始,找到常量正则表达式rx第一次出现的位置。如果index为-1,搜索从最后一个字符开始,如果是-1,从紧挨着最后一个字符的字符开始,依此类推。(对于反向搜索也可以参考findRev()。)

    返回rx第一次出现的位置,如果rx没有被找到,返回-1。

    QString string( "bananas" ); int i = string.find( QRegExp("an"), 0 ); // i == 1

    也可以参考findRev()、replace()和contains()。

    实例:network/mail/smtp.cpp

    int QChar c, int index = 0, bool cs = TRUE ) const

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

    从位置index开始,找到字符c第一次出现的位置。如果index为-1,搜索从最后一个字符开始,如果是-1,从紧挨着最后一个字符的字符开始,依此类推。(对于反向搜索也可以参考findRev()。)

    如果cs为真,那么匹配是区分大小写的。如果cs为假,那么匹配是不区分大小写的。

    返回c第一次出现的位置,如果c没有被找到,返回-1。

    int QString & str, int index = 0, bool cs = TRUE ) const

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

    从位置index开始,找到字符串str第一次出现的位置。如果index为-1,搜索从最后一个字符开始,如果是-1,从紧挨着最后一个字符的字符开始,依此类推。(对于反向搜索也可以参考findRev()。)

    如果cs为真,那么匹配是区分大小写的。如果cs为假,那么匹配是不区分大小写的。

    返回str第一次出现的位置,如果str没有被找到,返回-1。

    int find(QString(str), index)。

    int findRev(QString(str), index)。

    int QChar c, int index = -1, bool cs = TRUE ) const

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

    从位置index开始并且反向搜索,找到字符c第一次出现的位置。如果index为-1,搜索从最后一个字符开始,如果是-1,从紧挨着最后一个字符的字符开始,依此类推。

    返回c第一次出现的位置,如果c没有被找到,返回-1。

    如果cs为真,那么匹配是区分大小写的。如果cs为假,那么匹配是不区分大小写的。

    QString string( "bananas" ); int i = string.findRev( 'a' ); // i == 5

    int QString & str, int index = -1, bool cs = TRUE ) const

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

    从位置index开始并且反向搜索,找到字符串str第一次出现的位置。如果index为-1,搜索从最后一个字符开始,如果是-1,从紧挨着最后一个字符的字符开始,依此类推。

    返回str第一次出现的位置,如果str没有被找到,返回-1。

    如果cs为真,那么匹配是区分大小写的。如果cs为假,那么匹配是不区分大小写的。

    QString string("bananas"); int i = string.findRev( "ana" ); // i == 3

    int QRegExp & rx, int index = -1 ) const

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

    从位置index开始并且反向搜索,找到正则表达式rx第一次出现的位置。如果index为-1,搜索从最后一个字符开始,如果是-1,从紧挨着最后一个字符的字符开始,依此类推。

    返回rx第一次出现的位置,如果rx没有被找到,返回-1。

    QString string( "bananas" ); int i = string.findRev( QRegExp("an") ); // i == 3

    也可以参考find()。

    QString fromLatin1( "123456789", 5 ); // str == "12345"

    实例:listbox/listbox.cppnetwork/mail/smtp.cpp

    QString fromLocal8Bit( "123456789", 5 ); // str == "12345"

    local8Bit被假设使用本地指定的格式编码的。

    关于Unicode字符串的编码/解码更多变化请参考QTextCodec

    QString fromUtf8( "123456789", 5 ); // str == "12345"

    关于Unicode字符串的编码/解码更多变化请参考QTextCodec

    实例:fonts/simple-qfont-demo/viewer.cpp

    QString & QString & s )

    把s插入到字符串的index位置之前。

    如果index超过字符串的结尾,字符串被填充空格扩展到index长度并且然后s被添加,返回这个字符串的引用。

    QString string( "I like fish" ); str = string.insert( 2, "don't " ); // str == "I don't like fish"

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

    实例:themes/themes.cppxform/xform.cpp

    QString & QChar * s, uint len )

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

    把s中的字符插入到字符串的index位置之前len次并且返回这个字符串的引用。

    QString & QChar c )

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

    把c插入到字符串的index位置之前并且返回这个字符串的引用。

    如果index超过字符串的结尾,字符串被填充空格(ASCII码为32)扩展到index长度并且然后s被添加,返回这个字符串的引用。

    QString & length() == 0,返回真。因此,零字符串也是空字符串。

    QString a( "" ); a.isEmpty(); // 真 a.isNull(); // 假 QString b; b.isEmpty(); // 真 b.isNull(); // 真

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

    实例:addressbook/mainwindow.cppchart/chartform.cppchart/chartform_canvas.cppnetwork/networkprotocol/nntp.cppqmag/qmag.cppqwerty/qwerty.cpp

    bool unicode() == 0,a.length() == 0 a.isNull(); // 真,因为a.unicode() == 0 a.isEmpty(); // 真

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

    实例:i18n/main.cppqdir/qdir.cpp

    const char * QTextCodec类。

    这个函数主要对于使用Unicode的开机时的老程序有用处。

    只要源字符串的一个未修改复制存在,这个结果就保持有效。

    也可以参考utf8()和local8Bit()。

    实例:fileiconview/qfileiconview.cppnetwork/networkprotocol/nntp.cpp

    QString left( 4 ); // t == "Pine"

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

    实例:themes/themes.cpp

    QString QChar fill = ' ', bool truncate = FALSE ) const

    返回一个长度为width的,包含这个字符串,并且用fill填补的字符串。

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

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

    QString s( "apple" ); QString t = s.leftJustify( 8, '.' ); // t == "apple..."

    也可以参考rightJustify()。

    uint isNull()和isEmpty()。

    实例:fileiconview/qfileiconview.cppnetwork/networkprotocol/nntp.cpprot13/rot13.cppthemes/themes.cpp

    QCString QTextCodec::codecForLocale()。在Windows上,它是系统定义的编码方式。在Mac OS X上,总是使用utf8作为编码方式。

    关于Unicode字符串的编码/解码更多变化请参考QTextCodec

    也可以参考QString::fromLocal8Bit()、latin1()和utf8()。

    int QString & s1, const QString & s2 ) [静态]

    对s1和s2进行比较,如果s1小于、等于或者大于s2,就返回小于、等于或者大于0的整数。

    这个比较是基于本地的并且也是基于平台的方式。使用这个函数可以把排好序的字符串列表呈现给用户。

    也可以参考QString::compare()和QTextCodec::locale()。

    int QString & s ) const

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

    对这个字符串和s进行比较。

    QString lower(); // str == "trolltech"

    也可以参考upper()。

    实例:scribble/scribble.cpp

    QString mid( 5, 4 ); // t == "pine"

    也可以参考left()和right()。

    实例:network/mail/smtp.cppqmag/qmag.cppthemes/themes.cpp

    QString number( a, 16 ); // str == "3f" QString str = QString::number( a, 16 ).upper(); // str == "3F"

    也可以参考setNum()。

    实例:action/application.cppapplication/application.cppchart/chartform.cppfonts/simple-qfont-demo/viewer.cppmdi/application.cppsql/overview/extract/main.cpp

    QString setNum()。

    QString setNum()。

    QString setNum()。

    QString QString( "'E' format, precision 3, gives %1" ) .arg( d, 0, 'E', 3 ); // ds == "1.234E+001"

    也可以参考setNum()。

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

    bool isNull() ) doSomethingWith(name);

    QString & QString & str )

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

    QString & QChar c )

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

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

    QString & QString & QChar c )

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

    QString & QString & s )

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

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

    QString & 深度复制赋值给这个字符串并且返回这个字符串的引用。

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

    也可以参考isNull()。

    QString & QCString & cs )

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

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

    QString & QChar QCharRef QCharRef就可以引用字符串中的有效(零)字符。

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

    QString & QString & s )

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

    等于insert(0, s)。

    QString string = "42"; string.prepend( "The answer is " ); // string == "The answer is 42"

    也可以参考insert()。

    QString & insert(0, ch)。

    也可以参考insert()。

    QString & QChar ch )

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

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

    等于insert(0, ch)。

    也可以参考insert()。

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

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

    也可以参考constref()。

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

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

    QString & 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.cppnetwork/networkprotocol/nntp.cppqmag/qmag.cpp

    QString & QChar * s, uint slen )

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

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

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

    QString & QRegExp & rx, const QString & str )

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

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

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

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

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

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

    实例:fileiconview/qfileiconview.cpp

    QString 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 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 QString 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 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 QChar c )

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

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

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

    QString & isNull()和isEmpty()。

    void setLength( newLen ) // 分配一些空间 while ( ... ) { result[resultLength++] = ... // 填充(部分的)空格作为数据 } result.truncate[resultLength]; // 并且去掉不确定的垃圾

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

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

    QString & setNum( 1234 ); // string == "1234"

    QString & QString & QString & QString & QString & QString & arg()。

    QString & arg()。

    QString & QChar * unicode, uint len )

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

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

    QString & 字符串。

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

    QString 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 & utf8()编码字符串。格式化字符串cformat希望是一个Latin1的。如果你需要一个Unicode格式字符串,使用arg()来替代。为了完全支持Unicode的类型安全的字符串构建,你可以像这样使用QTextOStream

    QString str; QString s = ...; int x = ...; QTextOStream( &str ) << s << " : " << x;

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

    也可以参考arg()。

    实例:dclock/dclock.cppforever/forever.cpplayout/layout.cppqmag/qmag.cppscrollview/scrollview.cpptooltip/tooltip.cppxform/xform.cpp

    bool QString & s ) const

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

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

    也可以参考endsWith()。

    QString 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 toDouble(); // a == 1234.56

    也可以参考number()。

    float number()。

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

    也可以参考number()。

    long number()。

    short number()。

    ulong number()。

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

    也可以参考setLength()。

    实例:network/mail/smtp.cpp

    const QChar * QString upper(); // t == "TEXT"

    也可以参考lower()。

    实例:scribble/scribble.cppsql/overview/custom1/main.cpp

    QCString QTextCodec

    也可以参考QString::fromUtf8()、local8Bit()和latin1()。


     

    相关函数

    bool QString & s1, const QString & s2 )

    如果s1在词典中不等于s2,返回真,否则如果不是,返回假。这个比较是区分大小写的。注意一个零字符串不等于一个非零的空字符串。

    等于compare(s1, s2) != 0。

    bool QString & s1, const char * s2 )

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

    如果s1在词典中不等于s2,返回真,否则如果不是,返回假。这个比较是区分大小写的。注意一个零字符串不等于一个非零的空字符串。

    等于compare(s1, s2) != 0。

    bool QString & s2 )

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

    如果s1在词典中不等于s2,返回真,否则如果不是,返回假。这个比较是区分大小写的。注意一个零字符串不等于一个非零的空字符串。

    等于compare(s1, s2) != 0。

    const QString QString & s1, const QString & s2 )

    返回字符串s1和字符串s2连接的结果的字符串。

    等于s1.append(s2)。

    const QString QString & s1, const char * s2 )

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

    返回字符串s1和字符串s2连接的结果的字符串。

    等于s1.append(s2)。

    const QString QString & s2 )

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

    返回字符串s1和字符串s2连接的结果的字符串。

    const QString QString & s, char c )

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

    返回字符串s和字符c连接的结果的字符串。

    等于s.append(c)。

    const QString QString & s )

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

    返回字符c和字符串s连接的结果的字符串。

    等于s.prepend(c)。

    bool QString & s1, const char * s2 )

    如果s1在词典中小于s2,返回真,否则如果不是,返回假。这个比较是区分大小写的。注意一个零字符串不等于一个非零的空字符串。

    等于compare(s1, s2) < 0。

    bool QString & s2 )

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

    如果s1在词典中小于s2,返回真,否则如果不是,返回假。这个比较是区分大小写的。注意一个零字符串不等于一个非零的空字符串。

    等于compare(s1, s2) < 0。

    QDataStream & QDataStream & s, const QString & str )

    把字符串str写到流s中。

    也可以参考QDataStream操作符的格式

    bool QString & s1, const char * s2 )

    如果s1在词典中小于或等于s2,返回真,否则如果不是,返回假。这个比较是区分大小写的。注意一个零字符串不等于一个非零的空字符串。

    等于compare(s1,s2) <= 0。

    bool QString & s2 )

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

    如果s1在词典中小于或等于s2,返回真,否则如果不是,返回假。这个比较是区分大小写的。注意一个零字符串不等于一个非零的空字符串。

    等于compare(s1,s2) <= 0。

    bool QString & s1, const QString & s2 )

    如果s1在词典中等于s2,返回真,否则如果不是,返回假。这个比较是区分大小写的。注意一个零字符串不等于一个非零的空字符串。

    等于compare(s1, s2) != 0。

    bool QString & s1, const char * s2 )

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

    如果s1在词典中等于s2,返回真,否则如果不是,返回假。这个比较是区分大小写的。注意一个零字符串不等于一个非零的空字符串。

    等于compare(s1, s2) != 0。

    bool QString & s2 )

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

    如果s1在词典中等于s2,返回真,否则如果不是,返回假。这个比较是区分大小写的。注意一个零字符串不等于一个非零的空字符串。

    等于compare(s1, s2) != 0。

    bool QString & s1, const char * s2 )

    如果s1在词典中大于s2,返回真,否则如果不是,返回假。这个比较是区分大小写的。注意一个零字符串不等于一个非零的空字符串。

    等于compare(s1, s2) > 0。

    bool QString & s2 )

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

    如果s1在词典中大于s2,返回真,否则如果不是,返回假。这个比较是区分大小写的。注意一个零字符串不等于一个非零的空字符串。

    等于compare(s1, s2) > 0。

    bool QString & s1, const char * s2 )

    如果s1在词典中大于或等于s2,返回真,否则如果不是,返回假。这个比较是区分大小写的。注意一个零字符串不等于一个非零的空字符串。

    等于compare(s1, s2) >= 0。

    bool QString & s2 )

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

    如果s1在词典中大于或等于s2,返回真,否则如果不是,返回假。这个比较是区分大小写的。注意一个零字符串不等于一个非零的空字符串。

    等于compare(s1, s2) >= 0。

    QDataStream & QDataStream & s, QString & str )

    从流s中读取一个字符串到字符串str中。

    也可以参考QDataStream操作符的格式

    展开全文
  • Qt QStringQStringList

    2020-08-20 13:48:45
    QStringList 和 QString 互换 QStringList fonts; fonts << "Arial" << "Helvetica" << "Times" << "Courier"; QString str = fonts.join(","); QString str = "name1,path1;name2,...

    QStringList 和 QString 互换

    QStringList fonts;
    fonts << "Arial" << "Helvetica" << "Times" << "Courier";
    QString str = fonts.join(","); 
    
    
    QString str = "name1,path1;name2,path2;name3,path3";
    QStringList list1 = str.split(";"); 
    // 注意,如果str是空字符串,list1会增加一个空字符串到列表里,其size=1,我为此吃过苦头~
    for(int i=0;i<list1.size();i++)
    {
    QStringList list2 = list1[i].split(tr(","));
    }

    参考:https://www.cnblogs.com/findumars/p/4331049.html

    展开全文
  • QString详解

    千次阅读 2019-08-16 13:53:19
    一、初始化QString 1、最常用的初始化: QString str = "Hello"; 这实际上是使用QString::fromUtf8()将一个C语言风格的字符串: const char * p = "hello"; 转成QString。 p可以为空,以下写法是合法的: ...
  • QT QStringList 与 QString 常用方法

    千次阅读 2020-05-25 15:18:18
    QStringList转QString QStringList listemp; listemp << "Apple" << "Grape" << "Orange" << "Banana"; QString str = listemp.join(","); qDebug() << "\r\nstr:" << str; //...
  • QStringList与QString互相转化 QStringList fonts; fonts << "Arial" << "Helvetica" << "Times" << "Courier"; QString str = fonts.join(","); QString str = "name1,path1;name2,path...
  • QStringList与QString互转

    万次阅读 2018-06-26 10:09:18
    QStringList fonts; fonts &lt;&lt; "Arial" &lt;&lt; "Helvetica" &lt;&lt; "Times" &lt;&lt; "Courier"; QString str = fonts.join(&...
  • QString与16进制QString互转 QString转16进制QString 最基础的用法。最简单的技巧就是先转一下QByteArray格式。其中原本的字符串为str。 QByteArray array = str.toUtf8(); QString string1=array.toHex(); 转换的...
  • 一、QStringList 转化成 QString - 使用 join 函数 join 函数将 QStringList 中的所有字符串用一个分隔符连接起来变成一个字符串。例: strlist中有5个字符串,使用join将它们连起来,以逗号作为分隔符。结果为...
  • QT之QStringList、QString

    2019-10-23 09:13:08
    一、QStringList类提供字符串列表。 QStringList继承自QList。与QList一样,QStringList也是隐式共享的。它提供了快速的基于索引的访问以及快速的插入和删除。将字符串列表作为值参数传递既快速又安全。 QList的...
  • 十六进制 QStringQString

    千次阅读 2018-04-08 17:44:13
    在升级实现过程中,为了制作唯一的升级文件,所以升级过程中绑定...一般16进制QstringQstring如下即可:Qstring str("704e0520361c5434"); QByteArray temp(""); temp.append(str);QByteArra...
  • QString之arg

    2020-01-07 23:56:46
    QString的arg接口主要用于字符串组合的功能。
  • QString to base64QString , to unBase64QString

    千次阅读 2018-12-08 18:38:37
    QString qs2B64(QString qs1){//ok ////////////////////////////// QByteArray ba; ba=qs1.toUtf8(); //QByteArray ba=ba.toBase64(); //Base64 char * cx=ba.d...
  • QString::QString 中文乱码 处理方法: 1. QString str = QString::fromLocal8Bit("中文"); // vs2008 vs2005 2. QString str = QString::fromLocal8Bit("中文"); // gcc vs2003, 如源码...
  • QString拼接

    万次阅读 2018-01-23 23:42:31
    QString str1 = "Welcome";//传递一个const char* 类型的ASCII字符“Welcome”,会调用QString的构造函数 str1 = str1 + " to you!"; qDebug() QString str1 = "Welcome"; QString str2 = " to"; str1....
  • Qt QString详解

    2021-02-18 21:53:46
    1.QString 详解 //append 在后面添加字符串,prepend在前面添加字符串 QString s1 = "张"; QString s2 = "三"; QString s3 = s1; s1.append(s2); //s1 = "张三" s3.prepend(s2); //s3 = "三张" //toUpper...
  • QString replace

    2020-09-30 10:51:28
    QString的replace函数会改变原字符串,切记,他在返回替换后的新字符串的同时也会改变原字符串
  • QString str("100"); int tmp = str.toInt(); int tmp = 100; QString str = QString::number(tmp);``
  • QStringList 使用

    千次阅读 2018-12-31 16:15:24
    创建QString List 获取QStringList里面的元素 QStringList strList = item.split('#'); QString str1 = strList.at(0); QString str2 = strList.at(1);
  • QString 的用法

    2020-09-23 12:55:59
    Qt则提供了自己的字符串实现:QString,QString不用担心内存分配以及关于'\0'结尾的这些注意事项  另外,与C风格的字符串不同,QString中间是可以包含'\0'符号的,而length()函数则会返回整个字符串的长度,而不...
  • 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()<<s; //...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 79,057
精华内容 31,622
关键字:

qstring