附录：QString章节

附录：QString章节

内容转载至：https://blog.csdn.net/a10929/article/details/78066957

目录

• 附录：QString章节
  • 一、String之API函数
    • 1、构造
    • 2、数值转化
    • 2、查找
    • 3、添加，插入，替换，分割，删除，其他。
    • 4、 编码互转化
  • 二、QString之示例

一、String之API函数

1、构造

Qstring();                                       // 构造null字符串
QString(QChar ch);                               // 由 QChar对象ch构造  
QString(const QChar *unicode, int size = -1);    // 由QChar数组构造，size是数组大小
QString(const QByteArray & ba);                  // 由QbyteArray构造
QString(const QString &other);                  // 拷贝构造函数  
QString(const char *str);                  // 由c风格字符串 str 构造 

2、数值转化

//QString 类提供了很多函数用于字符串与数值之间的相互转换,类似于C标准库stdlib.h中的 atoi() , itoa()等函数


//str -> num    ok的作用是输出转化是否成功,base是字符串所代表的整数的进制
double toDouble(bool *ok = 0) const; // 转换为高精度浮点数
float toFloat(bool *ok = 0) cosnt; // 转换为浮点数
int toInt(bool *ok, int base = 10) const; // 转换为整型数
long toLong(bool *ok, int base = 10) cosnt; // 转换为长整型
short toShort(bool *ok, int base = 10) const; // 转换为短整型
uint toUInt(bool *ok = 0; int base = 10) const // 转换为无符号整型数
ulong toLong(bool *ok = 0, int base = 10) const; // 转换为无符号长整型数
ushort toUShort(bool *ok = 0, int base = 10) const; // 转换为无符号短整型数

//num -> str    将数字转化为字符串并赋给QString对象,base是转化后的字符串所代表的整数的进制
QString &setNum(int n, int base = 10); // 整型数
QString &setNum(uint n, int base = 10); // 无符号整型数
QString &setNum(long n, int base = 10); // 长整型
QString &setNum(ulong n, int base = 10); // 无符号长整型数
QString &setNum(short n, int base = 10); // 短整型数
QString &setNum(ushort n, int base = 10); // 无符号短整型数
QString &setNum(double n, char format = 'g', int precision = 6); // 高精度浮点数
QString &setNum(float n, char format = 'g', int precision = 6); // 浮点数

2、查找

• 在本字符串上查找是否出现了作为参数传递的字符串或QRegExp正则表达式，

//从前向后查找到第一个符合条件的字符串的位置,,没有返回-1,from可指定开始查找的位置
int indexOf(const QString & str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; 
//同上,只不过参数为QChar字符
int indexOf(QChar ch, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
//同上,参数为QRegExp正则表达式来匹配
int indexOf(const QRegExp & rx, int from = 0) const;

//与上边对应的有反向查找(从后向前)
int lastIndexOf(const QString & str, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
int lastIndexOf(QChar ch, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
int lastIndexOf(const QRegExp & rx, int from = -1) const;

//如果不需要位置,只需要判断参数字符串是否出现在本字符串中,用以下函数:
bool contains(const QString & str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
bool contains(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
bool contains(const QRegExp & rx) const;

3、添加，插入，替换，分割，删除，其他。

//添加
QString &append(const QString & str); // 向末尾添加 QString 对象
QString &append(const QChar * str, int len); //...QChar* 型字符串
QString &append(const QByteArray & ba); //...QByteArray 对象
QString &append(const char * str); //...C风格字符串
QString &append(char ch); //...普通字符
QString &append(QChar ch); //...QChar 字符

QString &prepend(const QString &str); // 在前面添加 QString 对象
QString &prepend(const QChar &str,int len); //...QChar* 型字符串
QString &prepend(const QByteArray& ba); //...QByteArray 对象
QString &prepend(const char *str); // ...C风格字符串
QString &pretend(char ch); //...普通字符
QString &prepend(QChar ch); // ...QChar 字符

//Ps：也可以用 push_back() 和 push_front() 函，或者直接用重载操作符 += 

//插入
QString &insert(int position, const QString & str); //向指定的position位置插入一个 QString 对象
QString &insert(int position, const QChar * unicode, int size); //同上
QString &insert(int position, QChar ch); //同上

//替换
QString &replace(int position, int n, const QString & after) //从position位置开始将原QString中的n个字符替换为after中的n个字符

QString &replace(int position, int n, const QChar * unicode, int size); //同上

QString &replace(int position, int n, QChar after); //同上

QString &replace(const QString & before, const QString & after, Qt::CaseSensitivity cs = Qt::CaseSensitive); //在原QString对象中查找before,然后替换为after,没找到则什么都不做

QString &replace(const QChar * before, int blen, const QChar * after, int alen, Qt::CaseSensitivity cs = Qt::CaseSensitive); //同上

QString &replace(QChar ch, const QString & after, Qt::CaseSensitivity cs = Qt::CaseSensitive); //同上

QString &replace(QChar before, QChar after, Qt::CaseSensitivity cs = Qt::CaseSensitive); //同上

QString &replace(const QRegExp & rx, const QString & after); //在元QString中匹配正则表达式rx,然后替换为after

//简单分割
QString left(int n) const; // 分割得到前n个字符构成的子字符串
QString right(int n) const; // 分割得到后n个字符构成的子字符串
QString mid（int position, int n = -1） const; // 从中间切割子字符串,position是切割位置,n是长度

//根据字符串或正则表达式分割
QStringList split(const QString & sep, SplitBehavior behavior = KeepEmptyParts, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; //在原QString对象中查找所有位置的sep,并根据sep为分割点将原QString对象分割为n个子字符串，如：原QString为 "abcCUTbacCUTcab"，sep为"CUT"，则分割得到{"abc","bac","cab"}

QStringList split(QChar sep, SplitBehavior behavior = KeepEmptyParts, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; //同上

QStringList split(const QRegExp & rx, SplitBehavior behavior = KeepEmptyParts) const; //同上

//删除
void chop(int n); //删除后n个字符
void truncate(int position); //删除从position后的所有字符
QString &remove(int position, int n); //从position位置处向后删除n个字符
QString &remove(const QString & str, Qt::CaseSensitivity cs = Qt::CaseSensitive); //删除原QString对象中出现的所有str
QString &remove(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive); //删除原QString对象中出现的所有ch字符
QString &remove(const QRegExp & rx); //删除原QString对象中根据正则表达式rx匹配到的所有位置

//其他
const QChar at(int position) const; //得到某个位置的字符,也可以直接用[]
void reserve(int size); //重新设置QString长度,若size小于当前长度,后面的会丢失
void squeeze(); //清除多余的没有存储字符的内存
void clear(); //清空字符串
int size(); //返回字符串长度
int capacity() const; //返回目前最多可以存储的字符数
bool isNull() const; //判断QString是否为null(还未分配内存空间)
bool isEmpty() const; //判断是否为空字符串( QString()既是null也是empty，而QString("")就只是empty )
QChar* date(); //返回QChar*字符串
void swap(QString & other); //与另一个QString对象交换
QString trimmed() const; //返回删除了开头和结尾的所有空白字符的QString对象(原QString不改变)
QString simplified() const; //返回删除了所有空白字符的QString对象(原QString不改变)
QString toLower(); //转为小写
QString toUpper(); //转为大写

4、 编码互转化

• 字符集相互转化(Unicode,utf-8,gbk,ascii)在不同的系统下如windows下,使用vs系列编译器时，因为源文件是采用gbk编码，所以直接将含中文的C风格字符串(或std::string等)转为QString会乱码，QString提供了一系列字符集相互转化的函数。

//其他编码不同的字符串转为QString(static函数)
QString fromLatin1(const char * str, int size = -1); //从latin1编码(ASCII编码的扩充)的C风格字符串转为QStirng
QString fromLatin1(const QByteArray & str); //从latin1编码(ASCII编码的扩充)的QByteArray转为QStirng
QString fromLocal8Bit(const char * str, int size = -1); //从gbk编码的C风格字符串...
QString fromLocal8Bit(const QByteArray & str); //从gbk编码的QByteArray...
QString fromRawData(const QChar * unicode, int size); //从QChar*...
QString fromStdString(const std::string & str); //从std::string(gbk编码)...
QString fromStdU16String(const std::u16string & str); //从u16string(utf16编码)...
QString fromStdU32String(const std::u32string & str); //从u32string(utf32编码)...
QString fromStdWString(const std::wstring & str); //从wstring(宽字节)...
QString fromUtf8(const char * str, int size = -1); //从utf-8编码的C风格字符串...
QString fromUtf8(const QByteArray & str); //从utf-8编码的QByteArray...
QString fromUtf16(const ushort * unicode, int size = -1); //从utf-16编码的ushort*...
QString fromWCharArray(const wchar_t * string, int size = -1); //wchar_t等同于ushort
QString fromUcs4(const uint * unicode, int size = -1); //从Ucs4(utf-32)编码的uint*...

//非静态
QString &setUnicode(const QChar * unicode, int size); //从QChar*...
QString &setUtf16(const ushort * unicode, int size); //从ushort*...

//从QString转为其他编码的字符串
QByteArray  toLatin1() const; //返回latin1编码的QByteArray...
QByteArray  toLocal8Bit() const； //返回gbk编码的QByteArray...
QByteArray  toUtf8() const; //返回utf-8编码的QByteArray...
std::string toStdString() const; //返回std::string...
std::u16string  toStdU16String() const; //返回u16string...
std::u32string  toStdU32String() const; //返回u32string...
std::wstring  toStdWString() const; //返回wstring...
const QChar *unicode() const; //返回QChar*

二、QString之示例

（1）QString::QString()

构造一个零字符串。这是一个不被分配任何东西的字符串，也就是说长度和数据指针都为0。如何理解？请看下面这个成员函数。

（2）bool QString::isNull() const

//如果字符串为零，返回真。零字符串总是空的。
QString a;          // a.unicode() == 0，a.length() == 0
a.isNull();         // 真，因为a.unicode() == 0
a.isEmpty();        // 真

（3）bool QString::isEmpty() const

//如果字符串为空，也就是如果length() == 0，返回真。因此，零字符串也是空字符串。
 QString a("");
 a.isEmpty();        // 真
 a.isNull();         // 假
 QString b;
 b.isEmpty();        // 真
 b.isNull();         // 真

（4）uint QString::length() const

返回字符串的长度。
零字符串和空字符串的长度都为0。

（5）QString & QString::append(const QString & str)

 //把str添加到字符串中并且返回结果的引用。
 QString string = "Test";
 string.append( "ing" );        // string == "Testing"

（6）QString QString::arg(const QString & a, int fieldwidth = 0) const

//这个函数将返回使用a来替换最低层出现的%i（i为'1'或'2'或……'9'）的字符串。
//fieldwidth值指定了填充到a中的最小空间。正值将产生右对齐文本，负值将产生左对齐文本。

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

（7）QChar QString::at(uint i) const

//返回在索引i处的字符，或者如果i超过字符串的长度返回0。
     const QString string( "abcdefgh" );
     QChar ch = string.at( 4 );
     // ch == 'e'

（8）int QString::compare(const 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

（9）int QString::contains(QChar c, bool cs = TRUE) const

返回在这个字符串中字符c出现的次数。如果cs为真，那么匹配是区分大小写的。如果cs为假，那么匹配是不区分大小写的。
     QString string( "Trolltech and Qt" );
     int i = string.contains( 't', FALSE );  // i == 3

（10）bool QString::startsWith(const QString & s) const

//如果字符串以s开始，返回真，否则返回假。
     QString string("Bananas");
     bool a = string.startsWith("Ban");      //  a == TRUE

（11）QString & QString::fill(QChar c, int len = -1 )

//填充字符串为len个字符的值c，并且返回字符串的引用。
//如果len为负数（默认），当前字符串长度被使用。
     QString str;
     str.fill( 'g', 5 );      // string == "ggggg"

（12）int QString::find(const QRegExp & rx, int index = 0) const

//从位置index开始，找到常量正则表达式rx第一次出现的位置。如果index为-1，搜索从最后一个字符开始，如果是-1，从紧挨着最后一个字符的字符开始，依此类推。返回rx第一次出现的位置，如果rx没有被找到，返回-1。
     QString string( "bananas" );
     int i = string.find( QRegExp("an"), 0 );    // i == 1

（13）QString & QString::insert(uint index, const QString & s)

//把s插入到字符串的index位置之前。
//如果index超过字符串的结尾，字符串被填充空格扩展到index长度并且然后s被添加，返回这个字符串的引用。
     QString string( "I like fish" );
     str = string.insert( 2, "don't " );
     // str == "I don't like fish"

（14）QString QString::left(uint len) const

//返回包含字符串最左面的len个字符的子字符串。
//如果len超过字符串的长度，则整个字符串被返回。
     QString s = "Pineapple";
     QString t = s.left( 4 );    // t == "Pine"

（15）int QString::localeAwareCompare(const QString & s1, const QString & s2) [静态]

//对s1和s2进行比较，如果s1小于、等于或者大于s2，就返回小于、等于或者大于0的整数。
//这个比较是基于本地的并且也是基于平台的方式。使用这个函数可以把排好序的字符串列表呈现给用户。

（16）QString QString::lower() const

//返回由这个字符串转换的小写字符串。
QString string( "TROlltECH" );
str = string.lower();   // str == "trolltech"

（17）QString QString::number (long n, int base = 10) [静态]

//一个把数字n转换为字符串的方便函数，n被基于base表示，默认为10，并且必须在2到36之间。
     long a = 63;
     QString str = QString::number( a, 16 );             // str == "3f"
     QString str = QString::number( a, 16 ).upper();     // str == "3F"

（18）QString &?QString::setNum(long n, int base = 10)

//设置字符串为打印的数据n，n是基于base并且返回这个字符串的引用。
//base默认为10并且必须在2到36之间。
     QString string;
     string = string.setNum( 1234 );     // string == "1234"

（19）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

（20）QString QString::trimmed() const

//移除字符串两端的空白字符。
     QString str = "  lots	 of
whitespace
 ";
     str = str.trimmed();
     // str == "lots	 of
whitespace"

（21） QString QString::mid(uint index, uint len = 0xffffffff) const

//返回包含这个字符串从index位置开始len个字符的字符串。
//如果这个字符串为空或者index超出范围，返回零。
//如果index + len超过这个字符串的长度，返回从index开始的整个字符串。

 QString sEmpty;
 QString sAfterMid0 = sEmpty.mid(1); //""
 
 QString sObject("I love china.");
 QString sAfterMid1 = sObject.mid(15);//""
 QString sAfterMid2 = sObject.mid(2); //"love china."
 QString sAfterMid3 = sObject.mid(2, sObject.length()); //"love china."
 QString sAfterMid4 = sObject.mid(2, sObject.length() - 2); //"love china."

（22）QString & QString::remove(uint index, uint len)

//从字符串中的index位置开始移除len个字符并且返回这个字符串的引用。
//如果index超出字符串的长度，就什么也不发生。
//如果index在字符串中间，但是index加上len超过字符串的结尾，这个字符串将从index开始被截短。

 QString sObjectRem("I am a programmer.");
 QString sAfterRem0 = sObjectRem.remove(20, 3); //"I am a programmer."
 QString sAfterRem1 = sObjectRem.remove(2, 3);  //"I a programmer."
 QString sAfterRem2 = sObjectRem.remove(2, 20); //"I"

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

//从字符串中的index位置开始使用s替换len个字符，并且返回这个字符串的引用。
//如果index超出字符串的长度，就什么也不被删除。
//如果index有效并且index + len超过字符串的结尾，那么这个字符串将从index开始被截短，并且s被添加到字符串的结尾。

 QString sObjectRep("The big pig.");
 QString sAfterRep0 = sObjectRep.replace(20, 3, "liu"); //"The big pig."
 QString sAfterRep1 = sObjectRep.replace(4, 3, "liu");  //"The liu pig."
 QString sAfterRep2 = sObjectRep.replace(2, 20, "liu"); //"Thliu"
 
 QString sObjectRep2("abcdefghijk.");
 QString sAfterRep3 = sObjectRep2.replace(2, 20, "liu"); //"abliu"