QString类

 QString 类是 Qt 中用于表示字符串的类，实现在 QtCore 共享库中。QString 类在实现上有以下特征。

1）字符串采用 Unicode 内部编码，可以表示世界上大多数语言的文字。

2）字符串的存储有引用计数，当一个 QString 对象被复制为另一个 QString 对象时，它们实际上指向相同的存储空间，仅仅是增加一个引用计数。

3）采用 “按需复制” 的技术，当指向相同存储空间的多个 QString 对象中的一个要被修改时，将真正复制一个新的字符串并进行修改。

构造

QString 类提供了很多不同原型的构造函数以方便使用。如：

[plain] view plaincopyprint?

1. Qstring(); // 构造空字符串
2. QString(QChar ch); // 由 QChar 对象 ch构造
3. QString(const QChar *pch, int size); // 由 QChar 数组pch构造，size 是数组大小
4. QString(const QString &obj); // 拷贝构造函数
5. QString(const char *str); // 由字符串 str 构造，str是一个普通字符串

Qstring();                                        // 构造空字符串QString(QChar ch);                           // 由 QChar 对象 ch构造QString(const QChar *pch, int size);    // 由 QChar 数组pch构造，size 是数组大小QString(const QString &obj);              // 拷贝构造函数QString(const char *str);                  //  由字符串 str 构造，str是一个普通字符串

由于存在这些构造函数，凡是可以用 QString 类作为参数的地方，都可以安全地使用 QChar 对象或普通的字符串。

判断

可以用下面的成员函数判断 QString 对象是否为空字符串：

[plain] view plaincopyprint?

1. bool isEmpty() const; // 判断是否为空字符串

bool isEmpty() const;    // 判断是否为空字符串

转换

QString 类提供了很多函数用于将字符串转换为数值，如：

[plain] view plaincopyprint?

1. double toDouble(bool *ok = 0) const; // 转换为高精度浮点数
2. float toFloat(bool *ok = 0) cosnt; // 转换为浮点数
3. int toInt(bool *ok, int base = 10) const; // 转换为整型数
4. long toLong(bool *ok, int base = 10) cosnt; // 转换为长整型
5. short toShort(bool *ok, int base = 10) const; // 转换为短整型
6. uint toUInt(bool *ok = 0; int base = 10) const // 转换为无符号整型数
7. ulong toLong(bool *ok = 0, int base = 10) const; // 转换为无符号长整型数
8. ushort toUShort(bool *ok = 0, int base = 10) const; // 转换为无符号短整型数

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;                 // 转换为无符号短整型数

这些函数能够解析 QString 对象的内容，将其转换为相应的数值。其中 ok 参数指向一个 bool 型变量， 这个参数用于输出转换是否成功的信息。base参数则是转换为整数类型时的基。这些函数都不会改变 QString 对象自身。

注意： 当字符串以 0x开头时，转换的基自动转换为16， 当字符串以0开头时，转换的基自动为8。

下面这些成员函数可以将一个数值转换为字符串并设为 QString 对象的值：

[plain] view plaincopyprint?

1. QString &setNum(int n, int base = 10); // 整型数
2. QString &setNum(uint n, int base = 10); // 无符号整型数
3. QString &setNum(long n, int base = 10); // 长整型
4. QString &setNum(ulong n, int base = 10); // 无符号长整型数
5. QString &setNum(short n, int base = 10); // 短整型数
6. QString &setNum(ushort n, int base = 10); // 无符号短整型数
7. QString &setNum(double n, char format = 'g', int precision = 6); // 高精度浮点数
8. QString &setNum(float n, char format = 'g', int precision = 6); // 浮点数

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);            // 浮点数

将浮点数转换为字符串时，format 参数指定转化格式，precision 参数指定转换结果的精度，既有效数组的个数。注意这些函数会改变 QString 对象本身的值，而以下的函数则采用了不同的做法，它们返回一个新的临时对象以供使用：

[plain] view plaincopyprint?

1. QString number(int n, int base = 10);
2. QString number(uint n, int base = 10);
3. QString number(long n, int base = 10);
4. QString number(ulong n ,int base = 10);
5. QString number(double n, char format = 'q', int precision = 6);

QString number(int n, int base = 10);QString number(uint n, int base = 10);QString number(long n, int base = 10);QString number(ulong n ,int base = 10);QString number(double n, char format = 'q', int precision = 6);

这些函数都是静态成员函数，因而与某个具体的对象无关，可以直接通过类名调用。

QString 类也提供了大小写转换的函数，如：

[plain] view plaincopyprint?

1. QString toLower() const; // 转换为小写
2. QString toUpper() const; // 转换为大写

QString toLower() const;    // 转换为小写QString toUpper() const;    // 转换为大写

这些函数都不会改变 QString 对象本身，而是将转换后的结果作为返回值。

比较

QString 类提供了一个函数用于两个 QString 对象的比较：

[plain] view plaincopyprint?

1. int compare(const QString &s1, const QString &s2, Qt::CaseSensitivity cs = Qt::CaseSensitive);

int compare(const QString &s1, const QString &s2, Qt::CaseSensitivity cs = Qt::CaseSensitive);

这是一个静态成员函数，它可以比较 s1 和 s2 的大小，参数 cs 有以下两个取值。

[plain] view plaincopyprint?

1. Qt::CaseInsensitive： 表示对大小写不敏感
2. Qt::Casesensitive ： 表示对大小写敏感

Qt::CaseInsensitive： 表示对大小写不敏感Qt::Casesensitive ：    表示对大小写敏感

返回值的含义如下：大于 0 表示 s1 大于 s2，等于 0 表示 s1 等于 s2， 小于 0 表示 s1 小于 s2。

为了方便使用，QString 类还提供了以下重载函数用于比较：

[plain] view plaincopyprint?

1. int compare(const QString &other, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

int compare(const QString &other, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

这个函数用于比较 QString 对象自身和 QString 对象 other。

实际上更为直观的是使用 QString 类的比较操作符，如：

[plain] view plaincopyprint?

1. bool operator < (StringType other) const; // 比较是否小于 other人
2. bool operator <= (StringType other) const; // 比较是否小于等于 other
3. bool operator == (StringType other) const; // 比较是否等于 other
4. bool operator > (StringType other) constt; // 比较是否大于 other
5. bool operator >= (StringType other) const; // 比较是否大于等于 other
6. bool operator != (StringType other) const; // 比较是否不等于 other

bool operator < (StringType other) const;        // 比较是否小于 other人bool operator <= (StringType other) const;      // 比较是否小于等于 otherbool operator == (StringType other) const;      // 比较是否等于 otherbool operator > (StringType other) constt;       // 比较是否大于 otherbool operator >= (StringType other) const;      // 比较是否大于等于 otherbool operator != (StringType other) const;       // 比较是否不等于 other

这里的 StringType 指的是 （const QString &）或 （const char *），哥也就是说，这些操作副既可以与 QString 对象比较，也可以与普通的字符串比较。它们的局限性是第一个操作数必须是 QString 对象，因此，Qt 中又定义了以下操作符：

[plain] view plaincopyprint?

1. bool operator < (const char *s1, const QString &s2); // 比较 s1 是否小于 s2
2. bool operator <= (const char *s1, const QString &s2); // 比较 s1 是否小于等于 s2
3. bool operator == (const char *s1, const QString &s2); // 比较 s1 是否等于 s2
4. bool operator > (const char *s1, const QString &s2); // 比较 s1 是否大于 s2
5. bool operator >= (const char *s1, const QString &s2); // 比较 s1 是否大于等于 s2
6. bool operator != (const char *s1, const QString &s2); // 比较 s1 是否不等于 s2

bool operator < (const char *s1, const QString &s2);                 // 比较 s1 是否小于 s2bool operator <= (const char *s1, const QString &s2);               // 比较 s1 是否小于等于 s2bool operator == (const char *s1, const QString &s2);               // 比较 s1 是否等于 s2bool operator > (const char *s1, const QString &s2);                 // 比较 s1 是否大于 s2bool operator >= (const char *s1, const QString &s2);               // 比较 s1 是否大于等于 s2bool operator != (const char *s1, const QString &s2);                // 比较 s1 是否不等于 s2

这些操作符不是 QString 类的成员，它们的第一个参数是普通字符串。

查找
用以下的成员函数可以判断 QString 对象是否包含指定的字符串或字符：

[plain] view plaincopyprint?

1. bool contains(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
2. bool contains(cosnt ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

bool contains(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;      bool contains(cosnt ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

用以下的成员函数可以得到 QString 对象包含某个特定字符串或字符的个数：

[plain] view plaincopyprint?

1. int count(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
2. int count(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

int count(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;int count(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

用以下的成员函数可以得到 QString 对象中某个特定字符串或字符出现的位置：

[plain] view plaincopyprint?

1. int indexOf(const QString &str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
2. int indexOf(QChar ch, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

int indexOf(const QString &str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;int indexOf(QChar ch, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

这里参数 from 是查找的起点，它可以为负数，-i 表示倒数第i个字符。查找的方向是从前往后。返回值是查找到的字符串或字符的位置，如果没有找到则返回 -1。

QString 类中还有与此功能相似的函数用于从后往前查找字符串或字符：

[plain] view plaincopyprint?

1. int lastIndexOf(const QString &str, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
2. int lastIndexOf(QChar ch, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) 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

字符串处理

QString 类支持用赋值操作符进行对象的复制，其赋值操作符的声明如下：

[plain] view plaincopyprint?

1. QString &operator = (const QString &other); // 复制另外一个 QString 对象
2. QString &operator = (const char *str); // 复制普通字符串
3. QString &operator = (char ch); // 复制字符
4. QString &operator = (QChar ch); // 复制 QChar 类对象

QString &operator = (const QString &other);        // 复制另外一个 QString 对象QString &operator = (const char *str);               // 复制普通字符串QString &operator = (char ch);                         // 复制字符QString &operator = (QChar ch);                       // 复制 QChar 类对象

以下的成员函数可以将另一个字符串或字符接在 QString 对象后面，形成一个整体的字符串：

[plain] view plaincopyprint?

1. QString &append(const QString &str); // 接续 QString 对象
2. QString &append(const char *str); // 接续普通字符串
3. QString &append(QChar ch); // 接续 QChar 对象

QString &append(const QString &str);                // 接续 QString 对象QString &append(const char *str);                    // 接续普通字符串QString &append(QChar ch);                            // 接续 QChar 对象 

它们的返回值是 QString 对象自己的引用，也就是说，可以用在这个返回值再次调用成员函数，形成连续的字符串接续操作。

为了让代码更直观， QString 类中还定义了一个操作符用于字符串的接续：

[plain] view plaincopyprint?

1. QString &operator += (const QString &other); // 续接 QString 对象
2. QString &operator += (const char *str); // 续接普通字符串
3. QString &operator += (char ch); // 接续字符型数据
4. QString &operator += (QChar ch); // 接续 QChar 对象

QString &operator += (const QString &other);     // 续接 QString 对象QString &operator += (const char *str);    // 续接普通字符串QString &operator += (char ch);    // 接续字符型数据QString &operator += (QChar ch);   // 接续 QChar 对象

它们的功能与 append 相同。由于 C++ 语言允许赋值操作符和复合赋值操作符的返回值作为左值使用，因此它们的返回值也被设计为 QString 对象自己的引用，故也可以连续操作。但由于复合赋值操作符的结合顺序是从右往左，要想先计算左边的操作数需要加括号。

与 append 函数功能类似，以下的成员函数也能够将另一个字符串或字符与 QString 对象连接起来，但是接在原字符串的前面：

[plain] view plaincopyprint?

1. QString &prepend(const QString &str); // 在前面接续 QString 对象
2. QString &prepend(const char *str); // 在前面接续普通字符串
3. QString &prepend(QChar ch); // 在前面接续 QChar 对象

QString &prepend(const QString &str);          // 在前面接续 QString 对象QString &prepend(const char *str);              // 在前面接续普通字符串QString &prepend(QChar ch);                      // 在前面接续 QChar 对象

功能更一般化的是在 QString 对象的任意位置插入另一个字符串或字符，如：

[plain] view plaincopyprint?

1. QString &insert(int position, const QString &str); // 插入字符串
2. QString &insert(int position, const QChar *pch, int size); // 插入 QChar 数组
3. QString &insert(int position, QChar ch); // 插入 QChar 对象

QString &insert(int position, const QString &str);                   // 插入字符串QString &insert(int position, const QChar *pch, int size);         // 插入 QChar 数组QString &insert(int position, QChar ch);                               // 插入 QChar 对象

这里 position 参数是要插入的位置，返回值也是对 QString 对象自己的引用。

与插入相反的操作是移除 QString 对象中的一部分，如：

[plain] view plaincopyprint?

1. QString &remove(int position, int n);

QString &remove(int position, int n);

这个函数可以移除 QString 对象中从位置 position 开始的 n 个字符，下面两个成员函数则可以从 QString 对象中移除指定的字符串或字符：

[plain] view plaincopyprint?

1. QString &remove(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive);
2. QString &remove(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive);

QString &remove(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive);QString &remove(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive);

以下是 QString 对象的替换操作：

[plain] view plaincopyprint?

1. QString &replace(int position, int n, const QString &after); // QString 对象
2. QString &replace(int position, int n, const QChar *pch, int size); // QChar 数组
3. QString &replace(int opsition, int n, QChar after); // QChar 对象

QString &replace(int position, int n, const QString &after);                    // QString 对象QString &replace(int position, int n, const QChar *pch, int size);            // QChar 数组QString &replace(int opsition, int n, QChar after);                                // QChar 对象

这三个函数的功能是将 QString 对象从 position 开始的 n 个字符替换为新内容，新内容分别由 QString 对象、QChar 数组 和 QChar 对象表示。

以下成员函数则可以搜索指定的字符串或字符并开始替换：

[plain] view plaincopyprint?

1. QString &replace(const QString &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive); // QString 替换为 QString
2. QString &replace(QChar ch, cosnt QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive); // QChar 替换为 QString
3. QString &replace(QChar before, QChar after, Qt::CaseSensitivity cs = Qt::CaseSensitive); // Qchar 替换为 QChar

QString &replace(const QString &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);      // QString 替换为 QStringQString &replace(QChar ch, cosnt QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);                       // QChar 替换为 QStringQString &replace(QChar before, QChar after, Qt::CaseSensitivity cs = Qt::CaseSensitive);                              // Qchar 替换为 QChar

下面这个成员函数可以清空一个 QString 对象的内容，使之成为空字符串。

[plain] view plaincopyprint?

1. void clear();

void clear();

而下面这个成员函数可以截断 QStrring 对象，也就是去掉指定位置后的所有内容：

[plain] view plaincopyprint?

1. void truncate(int position); // 从位置 position 截断，位置从0开始编号

void truncate(int position);      // 从位置 position 截断，位置从0开始编号

下面这个成员函数可以截掉 QString 对象最后的若干个字符：

[plain] view plaincopyprint?

1. void chop(int n); // 截掉最后的 n个字符

void chop(int n);     // 截掉最后的 n个字符

以下几个成员函数可以得到 QString 对象的子字符串：

[plain] view plaincopyprint?

1. QString left(int n) const; // 得到左边 n 个字符构成的子字符串
2. QString right(int n) const; // 得到右边 n 个字符构成的子字符串
3. QString mid（int position, int n = -1） const; // 从中间得到子字符串

QString left(int n) const;      // 得到左边 n 个字符构成的子字符串QString right(int n) const;    // 得到右边 n 个字符构成的子字符串QString mid（int position, int n = -1） const;  // 从中间得到子字符串

从中间得到子字符串时，参数 position 是子字符串的起始位置，参数 n 是字符串的个数，如果n 为 -1，则表示一直到原字符串的结尾。

注意上述三个函数并不修改 QString 对象自身，而是返回一个临时对象以供使用。

下面这个成员函数可以截去 QString 对象中头部和尾部的空白字符：

[plain] view plaincopyprint?

1. QString trimmed() const;

QString trimmed() const;

空白字符包括空格、回车、换行、制表符等字符。下面这个成员函数不仅能去掉 QString 对象头尾的空白字符，还能将中间的连续多个空白字符全部替换成一个空格：

[plain] view plaincopyprint?

1. QString simlified() const;

QString simlified() const;

加法操作符可以将两个字符串或字符连接起来并以 QString 临时对象的方式返回:

[plain] view plaincopyprint?

1. const QString operator+(const QString &s1, const QString &s2);
2. const QString operator+(const QString &s1, const char *s2);
3. const QString operator+(const char s1, const QString &s2);
4. const QString operator+(const QString &s, char ch);

const QString operator+(const QString &s1, const QString &s2);       const QString operator+(const QString &s1, const char *s2);const QString operator+(const char s1, const QString &s2);const QString operator+(const QString &s, char ch); 

注意加法操作符的两个操作数中必须至少有一个是 QString 对象，否则无法重载操作符。显然，加法操作副都不是 QString 类的成员。

索引

QString 类也像普通的字符串一样可以根据下标得到某个位置上的字符：

[plain] view plaincopyprint?

1. const QChar at(int position) const;

const QChar at(int position) const;

这是一个成员函数，更直观的方法是用以下的操作符：

[plain] view plaincopyprint?

1. const QChar operator[] (int position) const;
2. const QChar operator[] (uint position) const;

const QChar operator[] (int position) const;const QChar operator[] (uint position) const;

这样对 QString 对象的取字符操作就类似于对一个字符数组的操作。事实上，通过【】操作符得到的字符还可以被修改，要用到另外两个重载的【】操作符：

[plain] view plaincopyprint?

1. QCharRef operator[] (int position);
2. QCharRef operator[] (uint position);

QCharRef operator[] (int position);QCharRef operator[] (uint position);

返回的 QCharRef 类是一个辅助类，对它的修改将反映到原字符串中去。

统计

以下两个成员函数都可以得到 QString 对象中字符的个数：

[plain] view plaincopyprint?

1. int size() const;
2. int length() const;

int size() const;int length() const;

注意字符的个数并不一定等于字节数。