字符串操作

C++字符串操作

• 构造函数
  1）string(const char *s) ：将 string 对象初始化为 s 指向的字符串
  2）string(size_type n,char c) ：创建一个包含 n 个元素的 string 对象，其中每个元素都被初始化为字符 c
  3）string(const string &str) ：将一个 string 对象初始化为 string 对象 str（复制构造函数）
  4）string() ：创建一个默认的 string 对象，长度为 0（默认构造函数）

// 示例代码：
string str("Hello!");  // Hello！
string str(10,'a');    // aaaaaaaaaa
string str2(str1);     // Hello！
string str; 　　　　    // 创建一个空的 string 对象

• 获取字符串长度函数size() 和length()

string str("Hello,World!");  // Hello,World!
int strLen1 = str.length();  // 12
int strLen2 = str.size();    // 12

• string.insert() 插入字符串，函数原型如下：

string＆insert（size_t pos，const string＆str）;　　　// 在位置 pos 处插入字符串 str
string＆insert（size_t pos，const string＆str，size_t subpos，size_t sublen）;　// 在位置 pos 处插入字符串 str 的从位置 subpos 处开始的 sublen 个字符
string＆insert（size_t pos，const char * s）;　　　　// 在位置 pos 处插入字符串 s
string＆insert（size_t pos，const char * s，size_t n）;　// 在位置 pos 处插入字符串 s 的前 n 个字符
string＆insert（size_t pos，size_t n，char c）;　　　　　 // 在位置 pos 处插入 n 个字符 c
iterator insert (const_iterator p, size_t n, char c);　// 在 p 处插入 n 个字符 c，并返回插入后迭代器的位置
iterator insert (const_iterator p, char c);　　　　　　 // 在 p 处插入字符 c，并返回插入后迭代器的位置

string.substr() 获取子串,函数原型如下：

string substr（size_t pos = 0，size_t len = npos）const;  // pos 是子字符串的起始位置（索引，第一个字符的索引为 0），len 是子串的长度。

swap() 交换两个字符串,如下：

 string str1 = "hello,world!";
 string str2 = "HELLO,WORLD!";
 str1.swap(str2);
 cout << str1 << endl;  // HELLO,WORLD!
 cout << str2 << endl;  // Hello,World!

string.erase() 元素删除操作,函数原型如下：

string& erase (size_t pos = 0, size_t len = npos);　　　// 删除从 pos 处开始的 n 个字符
iterator erase (const_iterator p);　　　　　　　　　　　　// 删除 p 处的一个字符，并返回删除后迭代器的位置
iterator erase (const_iterator first, const_iterator last);　// 删除从 first 到 last 之间的字符，并返回删除后迭代器的位置

string.find() 查找字符,函数原型如下：

size_type find (const string& str, size_type pos = 0) const;  // 从字符串的 pos 位置开始（若不指定 pos 的值，则默认从索引 0 处开始），查找子字符串 str。如果找到，则返回该子字符串首次出现时其首字符的索引；否则，返回  string::npos
size_type find (const char *s, size_type pos = 0) const; 
size_type find (char ch, size_type pos = 0) const; 
size_type find (const char *s, size_type pos, size_type n); // 从字符串的 pos 位置开始（若不指定 pos 的值，则默认从索引 0 处开始），查找 s 的前 n 个字符组成的子字符串。如果找到，则返回该子字符串首次出现时其首字符的索引；否则，返回 string::npos

string.rfind() ; string.rfind() 与 string.find() 方法类似，只是查找顺序不一样， string.rfind() 是从指定位置 pos （默认为字符串末尾）开始向前查找，直到字符串的首部，并返回第一次查找到匹配项时匹配项首字符的索引。
string.find_first_of()
string.find_last_of()
string.find_first_not_of()
string.find_last_not_of()

• 其他函数：
  1、string.append() 在一个 string 对象后面附加一个 string ，如：
  string str1 = “hello,”;
  string str2 = “world!”;
  str1.append(str2); // Hello,World!
  2、string.push_back() 在一个 string 对象后面追加一个字符，如：
  string str1 = “hello,”;
  char ch= ‘A’;
  str1.push_back(ch); // Hello,A
  3、string.compare() 比较字符串的大小，如：
  1）返回 0，表示相等；
  2）返回结果小于 0，表示比较字符串中第一个不匹配的字符比源字符串小，或者所有字符都匹配但是比较字符串比源字符串短；
  3）返回结果大于 0，表示比较字符串中第一个不匹配的字符比源字符串大，或者所有字符都匹配但是比较字符串比源字符串长。
  4、empty() 判断字符串是否为空

QString 字符串操作

• 构造函数

//函数原型
QString(const QByteArray &ba)
QString(const char *str)
QString(QString &&other)
QString(const QString &other)
QString(QLatin1String str)
QString(int size, QChar ch)
QString(QChar ch)
QString(const QChar *unicode, int size = -1)
QString()

• append() 在字符串末尾添加字符串或字符

// 函数原型
QString &QString::append(const QString &str)
QString &QString::append(QChar ch)
QString &QString::append(const QChar *str, int len)

// 示例：
QString x = "free";
QString y = "dom";
x.append(y); // x == "freedom"
x.append(y,2); // x == "freedomdo"

• prepend() 在字符串前面添加\插入字符串

// 函数原型
QString &QString::prepend(const QString &str)
QString &QString::prepend(QChar ch)
QString &QString::prepend(const QChar *str, int len)

// 示例代码：
QString x = "ship";
QString y = "air";
x.prepend(y); // x == "airship"

• insert() 在字符串中指定位置插入字符或字符串

// 函数原型
QString &QString::insert(int position, const QString &str)  // 在位置索引position处，插入字符串str
QString &QString::insert(int position, QChar ch)

// 示例：
QString str = "Meal";
str.insert(1, QString("ontr")); // str == "Montreal"

• remove() 移除指定字符或字符串

//函数原型
QString &QString::remove(int position, int n) // 根据索引删除子字符串，position表示待删除子字符串第一个字符所在的位置索引，n表示待删除子字符串长度

QString &QString::remove(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) // 删除指定字符
QString &QString::remove(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) // 删除指定字符串
// ch 或 str表示需要删除的字符或子字符串，cs 表示是否区分大小写，Qt::CaseSensitive表示区分大小写，Qt::CaseInsensitive表示不区分大小写

// 示例代码：
QString s = "Montreal";
s.remove(1, 4); // s == "Meal"

QString t = "Ali Baba";
t.remove(QChar('a'), Qt::CaseInsensitive); // t == "li Bb"

• replace() 替换字符串中指定位置的内容

//函数原型
QString &QString::replace(int position, int n, const QString &after)
QString &QString::replace(int position, int n, QChar after)
// 表示将从position开始的n个字符组成的字符串，替换成after表示的字符或字符串
QString &QString::replace(QChar before, QChar after, Qt::CaseSensitivity cs = Qt::CaseSensitive)
QString &QString::replace(const QString &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive)
QString &QString::replace(QChar ch, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive)
// 表示将before表示的字符或字符串替换成after所表示的字符或字符串

// 示例代码：
QString x = "Say yes!";
QString y = "no";
x.replace(4, 3, y); // x == "Say no!"

QString str = "colour behaviour flavour neighbour";
str.replace(QString("ou"), QString("o")); // str == "color behavior flavor neighbor"

QString equis = "xxxxxx";
equis.replace("xx", "x"); // equis == "xxx"

• split() 根据指定字符，将字符串拆分为子字符串，并返回这些字符串的列表

// 函数原型
QStringList QString::split(const QString &sep, Qt::SplitBehavior behavior = Qt::KeepEmptyParts, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
QStringList QString::split(QChar sep, Qt::SplitBehavior behavior = Qt::KeepEmptyParts, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
// sep为指定的拆分符，behavior 有两个参数 Qt::KeepEmptyParts表示返回的结果列表里面保留空字符，Qt::SkipEmptyParts表示返回的结果列表里面不保留空字符

QStringList QString::split(const QRegExp &rx, Qt::SplitBehavior behavior = Qt::KeepEmptyParts) const
QStringList QString::split(const QRegularExpression &re, Qt::SplitBehavior behavior = Qt::KeepEmptyParts) const

// 示例代码：
QString str = "abc";
auto parts = str.split(QString()); // parts: {"", "a", "b", "c", ""}

QString str = "/a/b/c/";
auto parts = str.split(QString('/'));// parts: {"", "a", "b", "c", ""}

QString str = "/a/b/c/";
auto parts = str.split(QString('/'),Qt::SkipEmptyParts);// parts: {"a", "b", "c"}

• mid() 返回字符串的一个子字符串

// 函数原型：
QString QString::mid(int position, int n = -1) const // position为开始的索引位置，n为字符串长度
 // 如果位置索引超过字符串的长度，则返回空字符串。如果从给定位置开始的字符串中可用的字符少于n个，或者如果n为-1（默认值），则函数将返回指定位置可用的所有字符。

// 应用实例：
QString x = "Nine pineapples";
QString y = x.mid(5, 4);            // y == "pine"
QString z = x.mid(5);               // z == "pineapples"

• indexOf() 获取子字符串或字符在字符串中的位置索引，返回的是第一个匹配的位置索引值

// 函数原型：
int QString::indexOf(QLatin1String str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const // str表示需要查找的字符串，from 表示开始检索的起始位置
int QString::indexOf(QChar ch, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
int QString::indexOf(const QString &str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
//  Qt::CaseSensitivity cs = Qt::CaseSensitive 表示区分大小写，Qt::CaseInsensitive表示不区分大小写

// 示例：
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); 

• swap() 交换字符串

// 函数原型：
void QString::swap(QString &other)

// 示例：
QString str1 = "hehe"
QString str2 = "haha"
str1.swap(str2 ) // str1 == "haha",str2 == "hehe"

• compare() 比较字符串大小

// 函数原型：
int QString::compare(const QString &s1, const QString &s2, Qt::CaseSensitivity cs = Qt::CaseSensitive)

// 示例：
int x = QString::compare("aUtO", "AuTo", Qt::CaseInsensitive);// x == 0
int y = QString::compare("auto", "Car", Qt::CaseSensitive);   // y > 0
int z = QString::compare("auto", "Car", Qt::CaseInsensitive); // z < 0

• isEmpty() 判断字符串是否为空

// 函数原型
bool QString::isEmpty() const

// 示例：
QString().isEmpty();            // returns true
QString("").isEmpty();          // returns true
QString("x").isEmpty();         // returns false
QString("abc").isEmpty();       // returns false

• isNull() 判断字符串是否为NULL

// 函数原型
bool QString::isNull() const

// 示例：
QString().isNull();             // returns true
QString("").isNull();           // returns false
QString("abc").isNull();        // returns false

• endsWith() 判断字符串是否也某一子字符串或字符结尾

//函数原型：
bool QString::endsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

// 示例：
QString str = "Bananas";
str.endsWith("anas");         // returns true
str.endsWith("pple");         // returns false

• startsWith() 判断字符串是否也某一子字符串或字符开始

//函数原型：
bool QString::startsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

QString str = "Bananas";
str.startsWith("Ban");     // returns true
str.startsWith("Car");     // returns false

• 其他函数：

• push_back() ，将给定的其他字符串追加到此字符串的末尾。它相当于 append()，函数原型:void QString::push_back(const QString &other)
• push_front() 将给定的其他字符串前置到此字符串的开头。它相当于prepend()，函数原型:void QString::push_front(const QString &other)
• length() 获取字符串长度，函数原型： int QString::length() const
• size() 获取字符串大小，函数原型： int QString::size() const
  QString str = “World”;
  int n = str.size(); // n == 5
  str.data()[0]; // returns ‘W’
  str.data()[4]; // returns ‘d’