QT之QString

目录

• QT之QString
  • 1、QString概述
  • 2、QString方法
    • 2.一、构造函数
    • 2.二、判断是否为空字符串
    • 2.三、字符串转换为数值
    • 2.四、数值转换为字符串并设为 QString 对象的值
    • 2.五、大小写转换
    • 2.六、QString 对象的比较
    • 2.七、字符串处理
    • 2.7.一、追加
    • 2.7.二、查找
    • 2.7.三、插入
    • 2.7.四、移除
    • 2.7.五、替换
    • 2.7.六、搜索替换
    • 2.7.七、清空
    • 2.7.八、截断
    • 2.7.九、截断获取子字符串
    • 2.7.A、空白字符操做
    • 2.7.B、索引
    • 2.7.C、统计

QT之QString

引言：如下内容为网上整理，若有侵权还请告知！！

---

1、QString概述

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

• 字符串采用 Unicode 内部编码，能够表示世界上大多数语言的文字;

---

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

---

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

2、QString方法

2.一、构造函数

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是一个普通字符串

2.二、判断是否为空字符串

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

2.三、字符串转换为数值

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

//注意： 当字符串以 0x开头时，转换的基自动转换为16， 当字符串以0开头时，转换的基自动为8。
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;                 // 转换为无符号短整型数

2.四、数值转换为字符串并设为 QString 对象的值

• 将浮点数转换为字符串时，format 参数指定转化格式，precision 参数指定转换结果的精度，既有效数组的个数。注意这些函数会改变 QString 对象自己的值。

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

• 如下的函数则采用了不一样的作法，它们返回一个新的临时对象以供使用，这些函数都不会改变 QString 对象自身。这些函数都是静态成员函数，于是与某个具体的对象无关，能够直接经过类名调用。

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);

2.五、大小写转换

//QString 类也提供了大小写转换的函数，这些函数都不会改变 QString 对象自己，而是将转换后的结果做为返回值。
QString toLower() const;    // 转换为小写

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

2.六、QString 对象的比较

//QString 类提供了一个函数用于两个 QString 对象的比较：
int compare(const QString &s1, const QString &s2, Qt::CaseSensitivity cs = Qt::CaseSensitive);

//这是一个静态成员函数，它能够比较 s1 和 s2 的大小，参数 cs 有如下两个取值。
Qt::CaseInsensitive： //表示对大小写不敏感
Qt::Casesensitive ：  //表示对大小写敏感
//返回值的含义以下：大于 0 表示 s1 大于 s2，等于 0 表示 s1 等于 s2， 小于 0 表示 s1 小于 s2

• 为了方便使用，QString 类还提供了如下重载函数用于比较：这个函数用于比较 QString 对象自身和 QString 对象 other。

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

• 实际上更为直观的是使用 QString 类的比较操做符，这里的 StringType 指的是 （const QString &）或 （const char *），也就是说，这些操做副既能够与 QString 对象比较，也能够与普通的字符串比较。它们的局限性是第一个操做数必须是 QString 对象

bool operator < (StringType other) const;        // 比较是否小于 other人

bool operator <= (StringType other) const;      // 比较是否小于等于 other

bool operator == (StringType other) const;      // 比较是否等于 other

bool operator > (StringType other) constt;       // 比较是否大于 other

bool operator >= (StringType other) const;      // 比较是否大于等于 other

bool operator != (StringType other) const;       // 比较是否不等于 other

• 上述操做的局限性是第一个操做数必须是 QString 对象，所以，Qt 中又定义了如下操做符，这些操做符不是 QString 类的成员，它们的第一个参数是普通字符串。

bool operator < (const char *s1, const QString &s2);                 // 比较 s1 是否小于 s2

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

bool operator == (const char *s1, const QString &s2);               // 比较 s1 是否等于 s2

bool operator > (const char *s1, const QString &s2);                 // 比较 s1 是否大于 s2

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

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

2.七、字符串处理

2.7.一、追加

// QString  类支持用赋值操做符进行对象的复制，其赋值操做符的声明以下：
QString &operator = (const QString &other);        // 复制另一个 QString 对象 
QString &operator = (const char *str);               // 复制普通字符串
QString &operator = (char ch);                         // 复制字符 
QString &operator = (QChar ch);                       // 复制 QChar 类对象

//成员函数能够将另外一个字符串或字符接在 QString 对象后面，造成一个总体的字符串，它们的返回值是 QString 对象本身的引用，也就是说，能够用在这个返回值再次调用成员函数，造成连续的字符串接续操做。
 QString &append(const QString &str);                // 接续 QString 对象 
 QString &append(const char *str);                    // 接续普通字符串 
 QString &append(QChar ch);                            // 接续 QChar 对象

//为了让代码更直观， QString 类中还定义了一个操做符用于字符串的接续，它们的功能与 append 相同。因为 C++ 语言容许赋值操做符和复合赋值操做符的返回值做为左值使用，所以它们的返回值也被设计为 QString 对象本身的引用，故也能够连续操做。但因为复合赋值操做符的结合顺序是从右往左，要想先计算左边的操做数须要加括号。
 QString &operator += (const QString &other);     // 续接 QString 对象 
 QString &operator += (const char *str);    // 续接普通字符串 
 QString &operator += (char ch);    // 接续字符型数据
 QString &operator += (QChar ch);   // 接续 QChar 对象

//与 append 函数功能相似，如下的成员函数也可以将另外一个字符串或字符与 QString 对象链接起来，可是接在原字符串的前面：
QString &prepend(const QString &str);          // 在前面接续 QString 对象
QString &prepend(const char *str);              // 在前面接续普通字符串 
QString &prepend(QChar ch);                      // 在前面接续 QChar 对象

2.7.二、查找

//用如下的成员函数能够判断 QString 对象是否包含指定的字符串或字符
 bool contains(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;     
 bool contains(cosnt ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

//用如下的成员函数能够获得 QString 对象包含某个特定字符串或字符的个数：
 int count(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; 
 int count(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

//用如下的成员函数能够获得 QString 对象中某个特定字符串或字符出现的位置：这里参数 from 是查找的起点，它能够为负数，-i 表示倒数第i个字符。查找的方向是从前日后。返回值是查找到的字符串或字符的位置，若是没有找到则返回 -1。QString 类中还有与此功能类似的函数用于从后往前查找字符串或字符：
 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;

 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

2.7.三、插入

//功能通常化的是在 QString 对象的任意位置插入另外一个字符串或字符，如：
 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 对象中的一部分，如：
QString &remove(int position, int n);

2.7.四、移除

//这个函数能够移除 QString 对象中从位置 position 开始的 n 个字符，下面两个成员函数则能够从 QString 对象中移除指定的字符串或字符：
 QString &remove(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive); 
 QString &remove(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive);

2.7.五、替换

//如下是 QString 对象的替换操做，这三个函数的功能是将 QString 对象从 position 开始的 n 个字符替换为新内容，新内容分别由 QString 对象、QChar 数组 和 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 对象

2.7.六、搜索替换

//如下成员函数则能够搜索指定的字符串或字符并开始替换：
QString &replace(const QString &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);      // QString 替换为 QString

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

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

2.7.七、清空

//下面这个成员函数能够清空一个 QString 对象的内容，使之成为空字符串。
void clear();

2.7.八、截断

//而下面这个成员函数能够截断 QStrring 对象，也就是去掉指定位置后的全部内容：
void truncate(int position);      // 从位置 position 截断，位置从 0 开始编号
//下面这个成员函数能够截掉 QString 对象最后的若干个字符：
void chop(int n);     // 截掉最后的 n 个字符

2.7.九、截断获取子字符串

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

QString left(int n) const;      // 获得左边 n 个字符构成的子字符串

QString right(int n) const;    // 获得右边 n 个字符构成的子字符串

QString mid（int position, int n = -1） const;  // 从中间获得子字符串

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

2.7.A、空白字符操做

//下面这个成员函数能够截去 QString 对象中头部和尾部的空白字符：
//空白字符包括空格、回车、换行、制表符等字符。
QString trimmed() const；

//下面这个成员函数不只能去掉 QString 对象头尾的空白字符，还能将中间的连续多个空白字符所有替换成一个空格：
QString simlified() const;

加法操做符能够将两个字符串或字符链接起来并以 QString 临时对象的方式返回:注意加法操做符的两个操做数中必须至少有一个是 QString 对象，不然没法重载操做符。显然，加法操做副都不是 QString 类的成员。

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);

2.7.B、索引

//QString 类也像普通的字符串同样能够根据下标获得某个位置上的字符：
const QChar at(int position) const;

//更直观的方法是用如下的操做符：
 const QChar operator[] (int position) const; 
 const QChar operator[] (uint position) const;

//上述QString 对象的取字符操做就相似于对一个字符数组的操做,但上述操做不能修改字符，事实上，经过[]操做符获得的字符还能够被修改，要用到另外两个重载的[]操做符：
 QCharRef operator[] (int position);
 QCharRef operator[] (uint position);  //返回的 QCharRef 类是一个辅助类，对它的修改将反映到原字符串中去。

2.7.C、统计

• 如下两个成员函数均可以获得 QString 对象中字符的个数，注意字符的个数并不必定等于字节数。

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