string的使用

Posted 2021-11-24 aaaaaaaWoLan

文章目录

• C语言中的字符串
• • 两个面试题
• 标准库中的string类
• • 了解string类
• string类的常用接口说明
• 1.string类对象的常见构造
• 2.string类对象的容量操作
• • size/clear/resize/capacity
  • reserve
• 3.string类对象的访问及遍历操作
• • opetator[]
  • 迭代器(类似指针)
  • 范围for：
• 4. string类对象的修改操作
• • append
  • operator+=
  • c_str
  • find
  • rfind
  • substr
  • insert
  • erase
• getline

C语言中的字符串

C语言中，字符串是以’\\0’结尾的C一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数，
但是这些库函数与字符串是分离开的，不太符合OOP的思想，而且底层空间需要用户自己管理，稍不留神可
能还会越界访问。

两个面试题

字符串转整形数字
字符串相加

在OJ中，有关字符串的题目基本以string类的形式出现，而且在常规工作中，为了简单、方便、快捷，基本
都使用string类，很少有人去使用C库中的字符串操作函数

标准库中的string类

了解string类

string类的文档介绍

1. 字符串是表示字符序列的类
2. 标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作
   单字节字符字符串的设计特性。
3. string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信
   息，请参阅basic_string)。
4. string类是basic_string模板类的一个实例，它使用char来实例化basic_string模板类，并用char_traits
   和allocator作为basic_string的默认参数(关于更多的模板信息请参考basic_string)。
5. 注意，这个类独立于所使用的编码来处理字节:如果用来处理多字节或变长字符(如UTF-8)的序列，这个
   类的所有成员(如长度或大小)以及它的迭代器，将仍然按照字节(而不是实际编码的字符)来操作。比如还有wchar_t类型(2 bytes)，能更好地表示Unicode等编码，对应的还有wstring类。

总结：

1. string是表示字符串的字符串类
2. 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。
3. string在底层实际是：basic_string模板类的别名，typedef basic_string<char, char_traits, allocator>
string;
4. 不能操作多字节或者变长字符的序列。

在使用string类时，必须包含#include头文件 以及using namespace std;

string类的常用接口说明

1.string类对象的常见构造

(constructor))函数名称	功能说明
string() ;（重点）	构造空的string类对象，即空字符串
string(const char* s) ;（重点）	用C-string来构造string类对象
string(size_t n, char c) ;	string类对象中拷贝n个字符c
string(const string&s); （重点）	拷贝构造函数
string (const char* s, size_t n);	拷贝字符串s的前n个字符
string (const string& str, size_t pos, size_t len = npos);	从对象str的pos位置开始，拷贝len个字符

void Teststring()
{
	string s1; // 构造空的string类对象s1
	string s2("hello world"); // 用C格式字符串构造string类对象s2
	string s3(s2); // 拷贝构造s3
	string s4 = "hello world";//隐式类型转换
	string s5(s4, 0, 3);//从s4的第0个位置开始，拷贝s4从该位置开始的3个字符
	string s6("123456", 3);//拷贝字符串123456的前3个字符
	string s7(10, 'y');//获取10个'y'

	cout << s1 << endl;
	cout << s2 << endl;
	cout << s3 << endl;
	cout << s4 << endl;
	cout << s5 << endl;
	cout << s6 << endl;
	cout << s7 << endl;
}

打印结果：

对于s5和s6的创建，如果我们给的最后一个参数大于字符串的长度怎么办？

试一试就知道了：

我们发现，结果是把字符串中剩余的内容给拷贝了。所以当指定拷贝的长度大于被拷贝字符串的长度时，是将字符串对应位置中剩余的内容全部拷贝。

回到表格中第六个重载函数的原型，我们看到参数len是一个缺省参数，缺省值为npos，npos是多少呢？它的值被赋为-1，但它是一个无符号的整型，所以对应的值其实是INT_MAX，也就是说，如果这个参数没有填，就会被设置成INT_MAX，从源字符串中拷贝INT_MAX个字符，实际上是不可能的，所以只会拷贝源字符串中从pos开始剩下的所有字符。

2.string类对象的容量操作

函数名称	功能说明
size（重点）	返回字符串有效字符长度
length	返回字符串有效字符长度
capacity	返回空间总大小
empty （重点）	检测字符串释放为空串，是返回true，否则返回false
clear （重点）	清空有效字符，并不会将容量清空
reserve （重点）	为字符串预留空间
resize （重点）	将有效字符的个数改成n个，多出的空间用字符c填充

length和size的作用相同，empty即判断对象字符串是否为空串

size/clear/resize/capacity

// size/clear/resize/capacity
void Teststring1()
{
// 注意：string类对象支持直接用cin和cout进行输入和输出
string s("hello, world!!!");
cout << s.size() << endl;
cout << s.length() << endl;
cout << s.capacity() << endl;
cout << s <<endl;
    
// 将s中的字符串清空，注意清空时只是将size清0，不改变底层空间的大小
s.clear();
cout << s.size() << endl;
cout << s.capacity() << endl;
    
// 将s中有效字符个数增加到10个，多出位置用'a'进行填充
// “aaaaaaaaaa”
s.resize(10, 'a');
cout << s.size() << endl;
cout << s.capacity() << endl;
    
// 将s中有效字符个数增加到15个，多出位置用缺省值'\\0'进行填充
// "aaaaaaaaaa\\0\\0\\0\\0\\0"
// 注意此时s中有效字符个数已经增加到15个
s.resize(15);
cout << s.size() << endl;
cout << s.capacity() << endl;
cout << s << endl;
    
// 将s中有效字符个数缩小到5个
s.resize(5);
cout << s.size() << endl;
cout << s.capacity() << endl;
cout << s << endl;
}

结果：

reserve

reserve可以修改对象可存储字符的最大空间，当我们需频繁添加字符时，可以直接用reserve将容量扩大。

//利用reserve提高插入数据的效率，避免增容带来的开销
void Teststring()
{
string s;
// 测试reserve是否会改变string中有效元素个数
s.reserve(100);
cout << s.size() << endl;
cout << s.capacity() << endl;
    
// 测试reserve参数小于string的底层空间大小时，是否会将空间缩小
s.reserve(50);
cout << s.size() << endl;
cout << s.capacity() << endl;
}

可以看到reserve只会改变容量大小，并不会改变有效元素个数。并且当reserve参数小于原容量大小时，不会将空间缩小，而是保持不变。

当对象的字符串长度变大时，可能会造成容量不足，此时会进行自动增容，而增容的大小是按一定规律来的，如果我们输入的字符串够长，就需要频繁增容

像下面这种情况就需要反复增容

void Test1()
{
    string s;
    size_t sz = s.capacity();
    for (int i = 0; i < 100; ++i)
    {
        s.push_back('c');
        if (sz != s.capacity())
        {
            cout <<sz<< "->" << s.capacity() << '\\n';
            sz = s.capacity();
        }
    }
}

如果我们事先知道需要增加多少空间，就可以用reserve一次增容就行

修改如下：

void Test2()
{
    string s;
    //将容量增加到100
    s.reserve(100);
    size_t sz = s.capacity();

    for (int i = 0; i < 100; ++i)
    {
        s.push_back('c');
        if (sz != s.capacity())
        {
            sz = s.capacity();
            cout << "capacity changed: " << sz << '\\n';
        }
    }
}

这样就不用进行反复的增容，一次就将容量增加到合适的大小了。

注意：

1. size()与length()方法底层实现原理完全相同，引入size()的原因是为了与其他容器的接口保持一
   致，一般情况下基本都是用size()。
2. clear()只是将string中有效字符清空，不改变底层空间大小。
3. resize(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到n个，不同的是当字
   符个数增多时：resize(n)用0来填充多出的元素空间，resize(size_t n, char c)用字符c来填充多出的
   元素空间。注意：resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大
   小，如果是将元素个数减少，底层空间总大小不变。
4. reserve(size_t res_arg=0)：为string预留空间，不改变有效元素个数，当reserve的参数小于
   string的底层空间总大小时，reserver不会改变容量大小。

3.string类对象的访问及遍历操作

函数名称	功能说明
operator[] （重 点）	返回pos位置的字符，const string类对象调用
begin+ end	begin获取一个字符的迭代器 + end获取最后一个字符下一个位置的迭 代器
rbegin + rend	begin获取一个字符的迭代器 + end获取最后一个字符下一个位置的迭 代器
范围for	C++11支持更简洁的范围for的新遍历方式

opetator[]

类似C语言里的数组，我们可以通过符号[]来取出对应下标位置的字符

operator[]有重载：也就是一个可以修改内容，一个不可以。

对于第一个重载，是可以对string内容修改的，对于第二个重载，是不可以的。

举例：

// 1. for+operator[]
void Test1()
{
	string s("hello world!!!");

	for (size_t i = 0; i < s.size(); ++i)
		cout << s[i];
	cout << endl;
}

另外还有一个接口at()也可以实现取出i位置的字符：

但是他们两个有区别，使用[]越界是用断言停止运行，而使用at()则是抛出异常，也就是还有商量的余地。不推荐使用at()

迭代器(类似指针)

使用：

//2.迭代器
void Test2()
{
	string s("hello world!!!");

	string::iterator it = s.begin();
	while (it != s.end())//一定要写出!=，不能写其他的
	{
		cout << *it;
		++it;
	}
	cout << endl;
}

注意：end()返回的不是最后一个数据的位置，而是最后一个位置的下一个位置

C++中凡是给迭代器一般都是给的左闭右开的区间：[ )

对应于begin()和end()，还有cbegin()和cend()接口，这两个函数对应的迭代器就是const_iterator，也就是迭代过程中是不能修改对象的。而begin()和end()是可以的。

迭代器意义：像string、vector(使用数组实现，空间连续)支持[]形式的遍历，但是list、map(使用链表实现，空间不连续)等等容器不支持，于是我们就要用迭代器遍历，所以迭代器是一种统一使用的方式

反向迭代器

void Test2()
{
    string s("hello world!!!");
    string::reverse_iterator rit = s.rbegin();//取开头是调用rbegin接口

	while (rit != s.rend())//结尾就是rend接口
	{
		cout << *rit;
		++rit;
	}
	cout << endl;
}

反向输出：

范围for：

//3.范围for
void Test3()
{
	string s("hello world!!!");
    //依次取容器中的数据，赋给e，自动判断结束
	for (auto e : s)//e也可以写成char，不过auto可以自行推导类型
	{
		cout << e;
	}
	cout << endl;
}

当然，范围for也可以进行赋值，不过要使用引用：

string s("12345");
	for (auto& e : s)
	{
		++e;
		cout << e;
	}
	cout << endl;

上面三种方法中，第一种方法对于string使用最多。

4. string类对象的修改操作

函数名称	功能说明
push_back	在字符串后尾插字符c
append	在字符串后追加一个字符/字符串
operator+= (重点)	在字符串后追加字符串str
c_str(重点)	返回C格式字符串
find + npos(重点)	从字符串pos位置开始往后找字符c，返回该字符在字符串中的位置
rfind	从字符串pos位置开始往前找字符c，返回该字符在字符串中的位置
substr	在str中从pos位置开始，截取n个字符，然后将其返回

append

push_back十分简单，就是在对象尾部添加一个字符，而一个一个字符地添加效率太低了，append可以帮我们解决问题，append既可以添加单个字符，也可以添加字符串。当然，也可以添加一个对象的内容

void TestChange1()
{
	string s("hello");
	s.append(" world");
    cout << s << endl;
    string s1("aaa");
    s.append(s1);
	cout << s << endl;
}

append还有多个重载：

//从对象str的subpos位置开始，添加sublen个字符
string& append (const string& str, size_t subpos, size_t sublen);

//添加字符串s的前n个字符
string& append (const char* s, size_t n);

//添加n个字符c
string& append (size_t n, char c);

//从一个对象的first位置开始到last结束，添加该段内容
string& append (InputIterator first, InputIterator last);

使用：

	string s("hello");
	string s1("aaaaaa");
	s.append(s1);
	cout << s << endl;

	s.append(s1, 0, 1);
	cout << s<<endl;

	s.append("bbb", 1);
	cout << s << endl;

	s.append(3, 'c');
	cout << s << endl;

	s.append(s1.begin(), s1.end());
	cout << s << endl;

operator+=

还有一个更简便的方式：operator+=

+=类似于append，可以+=的对象有单个字符、字符串、以及其他string对象。

string& operator+= (char c);

string& operator+= (const char* s);

string& operator+= (const string& str);

例：

void TestChange2()
{
	string s("hello");
	cout << s << endl;

	s += ' ';
	s += 'w';
	s += 'o';
	s += 'r';
	s += 'l';
	s += 'd';
	cout << s << endl;

	s += "aaaa";
	cout << s << endl;

	string s1("hehe");
	s += s1;

	cout << s << endl;

}

注意：

1. 在string尾部追加字符时，s.push_back© / s.append(1, c) / s += 'c’三种的实现方式差不多，一般
   情况下string类的+=操作用的比较多，+=及append操作不仅可以连接单个字符，还可以连接字符串。
2. 对string操作时，如果能够大概预估到放多少字符，可以先通过reserve把空间预留好

有这三种在尾部添加的方式，那有没有直接在头部添加字符的方式呢？string中没有专门添加在头部添加字符的接口函数，虽然可以实现，但效率低下。

c_str

c_str是将对象中的字符串以C形式返回。

看一个例子就知道c_str的特点了：

void Testc_str()
{
    string s("hello world");

    s.resize(20);
    s += "haha";

    cout << s << endl;
    cout << s.c_str() << endl;
    
}

我们将只有11个字符的对象s的有效字符个数添加到20，多出来的9个自动补\\0，再添加字符串haha，分别直接输出s和用c_str输出s，发现用c_str只输出了 hello world，这是因为 hello world后是 \\0，所以c_str就默认读取结束了。

find

我们重点只说明下面的重载(还可以搜索字符串)：

size_t find (char c, size_t pos = 0) const;

函数功能：从pos位置开始，查找一个c字符，找到了就返回该位置(从左到右第一个出现的位置)。没找到就返回npos，即INT_MAX，实际上是不可能有这么长的字符串的，也就意味着搜索失败。

使用示例：

void TestFind()
{
    string s("test.cpp");

    size_t pos = s.find('.', 0);
    if (pos == string::npos)
    {
        cout << "no" << endl;
    }
    else
    {
        cout << pos << endl;

    }
}

rfind

find是从前向后查找，那么rfind自然就是从后向前查找了。

同样，我们也只解释下面这个重载

size_t rfind (char c, size_t pos = npos) const;

功能：从pos位置开始向前查找字符c，返回结果与find相同

示例：

void test_rfind()
{
    string s("www.cplusplus.com");

    size_t pos = s.rfind('.', s.size() - 1);

    if (pos == string::npos)
    {
        cout << "no" << endl;
    }
    else
    {
        cout << pos << endl;
    }


}

substr

substr没有重载

string substr (size_t pos = 0, size_t len = npos) const;

功能：从pos位置开始，取len个长度的字符串，以string的形式返回。

示例：

void TestSubstr()
{
    string s("hello world");

    string s1 = s.substr(6, 5);//从s的位置6开始，取出长度为5的字符串

    cout << s << endl;
    cout << s1 << endl;

}

学了find、rfind以及substr后，我们就可以取出一个文件名的后缀，以及将一个网站中的协议名与域名取出:

取出文件后缀：

// 获取file的后缀
void Teststring1()
{
    
    string file("string.cpp");
    size_t pos = file.rfind('.');
    string suffix = file.substr(pos);
    cout << suffix << endl;
    
}

如果要取出的是 test.txt.dat这种文件名的后缀呢？

使用rfind与substr的组合即可

获取网站的协议名与域名

在一个网站http://www.cplusplus.com/reference/string/string/find/中，http是协议名，www.cplusplus.com是域名。

思路：用find找到字符串://的位置pos，再用substr取出从0位置开始，长度为pos的字符串，即可得到域名。

上面我们得到了pos，pos+3就是域名的起始位置，找到了起始位置，接下来要找的就是结尾，我们观察到，从域名开始，到第一个/，即为域名的结束。所以我们从pos+3的位置开始查找 /，就得到了域名的结尾，将该段字符串取出，即可的到域名

// 取出url中的域名
void Teststring2()
{
    string url("http://www.cplusplus.com/reference/string/string/find/");
    cout << url << endl;
    size_t start = url.find("://");

    //如果没有://，说明是无效协议
    if (start == string::npos)
    {
        cout << "invalid url" << endl;
        return;
    }
    else
    {
        string tmp = url.substr(0, start);//取出协议
        cout << tmp 以上是关于string的使用的主要内容，如果未能解决你的问题，请参考以下文章
 
 如何理解这段代码片段中的两对括号？
 Failed to convert property value of type ‘java.lang.String‘ to required type ‘int‘ for property(代码片段
 面试常用的代码片段
 golang代码片段（摘抄）
 10个JavaScript代码片段，使你更加容易前端开发。
 10个JavaScript代码片段，使你更加容易前端开发。