C++入门篇之string使用

string的对象构造(初始化)

string类对象的常见构造

 代码段如下：

 运行结果：

string类对象的容量操作

什么叫容量操作呢?就是对string的大小进行操作,比如访问,缩减,增加等,这里选取最常用的接口进行讲解,主要如下:

 1.size()和capacity()

文档的定义如下：size_t size() const和size_t capacity() const;

 测试结果如下：

 2. empty()和clear();

文档的定义如下：bool empty() const和void clear();

代码段：

 运行结果：

 这里需要注意的是clear清空的是s1中的内容，而s1的capacity并没有发生变化。

3.resize()

文档中有这两个定义void resize (size_t n);void resize (size_t n, char c);，到底是什么意思呢？

• 当n小于原来的字符串大小时候,那么resize就相当于变成void resize (size_t n);,即只会缩短到n长度
• 当n大于原来的字符串大小时候,那么resize就相当于变成void resize (size_t n, char c = '\0');,即多出来的部分,用c初始化

注意！上面说的分情况是指可以这样理解,并不是真的变成这样了,只是为了把官方文档的所有功能进行综合一下.

string s1("waiting for love");
	cout <<"原始长度                                               :"<< s1 << endl;//waiting for love
	s1.resize(5);
	cout << "缩短到5个字符的s1，                                    :" <<s1<<endl;//运行结果为 waiti
	s1.resize(9);
	cout << "长度大于原始长度9 ，多出来的部分用0初始化              :" <<s1 << endl;//运行结果为waiti   \

	s1.resize(13,'a');
	cout <<"长度增加到13，多出来的部分用a初始化                    :"<<s1 << endl;// 运行结果为waiti    aaaa
	s1.resize(3,'a');//长度小于原始长度13，即是缩短，传入的字符a无效
	cout << "长度增加到13，多出来的部分用a初始化                    :" << s1 << endl;//运行结果为wai

	return 0;

注意！这里的resieze值得是字符串中有效字符，而非capacity。

4.reserve()

官方的文档定义如下：void reserve (size_t n = 0);作用是预先改变capacity,但是这里值得注意的是这里和resize不一样,并且只有n大于原来capacity才起效果，效果指的是编译器可能会把capacity调整到大于等于n的地步.。而当小于原来的capacity则不起作用。

int main()
{
	string s1("Mccaine ");
	cout << "原来的容量" <<s1.capacity()<< endl;
	s1.reserve(10);//容量小于起始容量，不起作用
	cout << "现在的容量" << s1.capacity() << endl;
	s1.reserve(60);//容量设置为60，大于起始容量
	cout << "现在的容量" << s1.capacity() << endl;
	cout << "现在的s1为" << s1 << endl;//说明不改变原始数据




	return 0;
}

运行结果如下：

string的访问和遍历操作

1.string的访问。

上面说了string对象的定义初始化,以及其容量操作后。那我们如何进行访问呢？c++提供了以下的访问方式。

 []形式访问

官网是是这样定义的：char& operator[] (size_t pos);const char& operator[] (size_t pos) const;很多时候我们用的是第一种，但是当对象被cosnt修饰的时候，采用第二种。

//用下标访问
	string s1("20190922");
	const string s2("20170331");
	for (int i = 0; i < s1.size(); i++)
	{
		cout << s1[i] << " ";

	}
	cout << endl;
	s2[2] = '4';//这里会报错，以为s2[4]调用的是第二个,不允许对象修改.

运行结果如下：

迭代器

对于我们刚才接触迭代器,对于迭代器的概念理解有点困难,现阶段我们就理解为指为指针。目前我们最常用的迭代器有4个,分别是begin(),end(),rbegin(),rend();

正向迭代器其格式：iterator begin();const_iterator begin() const;当队形被const 修饰时，采用第二种方式。

当对象没有被const修饰是，代码如下

	string s1("20190922");
	const string s2("20170331");
	string::const_iterator ita = s2.begin();
	string::const_iterator itb = s2.end();
	while (ita != itb)
	{
		cout << *ita << " ";

		ita++;
	}
	cout << endl;

运行结果如下：

 当对象被const修饰时

反向迭代器，就是反向遍历string对象，其格式为：

string s1("20190922");
	const string s2("20170331");

	string::reverse_iterator ita = s1.rbegin();
	string::reverse_iterator itb = s1.rend();
	while (ita != itb)
	{
		cout << *ita << " ";

		ita++;
	}
	cout << endl;

 运行结果：

 范围for()

其格式为for(type i : object) {}，这里的i可以为任何形式，而且这里type，可以直接用auto,更加方便。

string s1("12345678");
	for (auto i : s1)
	{
		i += 1;
	}
	cout << s1 << endl;//这一步并没有用,因为i的类型不是auto&
	for (auto &i : s1)
	{
		i += 1;
	}
	cout << s1 << endl;

 运行结果为：

 string类对象的修改操作

 push_back()

其格式为：void push_back (char c)，就是在字符串末尾插入字符；

int main()
{
	string s1("hello");
	s1.push_back('w');
	cout << s1 << endl;
	s1.push_back('o');
	cout << s1 << endl;

	s1.push_back('r');
	cout << s1 << endl;

	s1.push_back('1');
	cout << s1 << endl;

	s1.push_back('d');
	cout << s1 << endl;
}

 运行结果为：

 append

对于append官方文档定义很多重载，这里介绍几个常用的：

string& append (const string& str); 末尾添加string对象.
string& append (const char* s); 末尾添加c格式字符串
string& append (const char* s, size_t n); 末尾添加字符串的前n个字符.
string& append (size_t n, char c); 末尾添加n个字符c

int main()
{
	string s1("Mccaine");
	string s2("I want to see you");
	char str[] = "Cassie";
	s2.append(s1);
	cout << s2 << endl;//添加string对象

	s2.append(str);
	cout << s2 << endl;//末尾添加C格式字符串

	s2.append(s1, 3);
	cout << s2 << endl;//末尾添加s1中的前三个字符

	s2.append(3, 'a');
	cout << s2 << endl;//末尾添加三个字符a;

	return 0;
}

运行结果为： 

 operator+=

官方的文档有以下定义：

string (1)	string& operator+= (const string& str);
c-string (2)	string& operator+= (const char* s);
character (3)	string& operator+= (char c);

一句话，就是可以拼接字符和字符串。

int main()
{
	string s1("hello ");
	string s2("world");
	s1 += ' ';//拼接一个空格
	cout << s1 << endl;

	s1 += "Cassie";//拼接字符
	cout << s1 << endl;
	s1 += ' ';//拼接一个空格

	s1 += s2;//拼接string对象，即字符串。
	cout << s1 << endl;
	return 0;
}

 其运行结果为：

find（）

对于 find（），官方的文档是这样定义的：

最上面3种可以记忆，只有3个参数,一个是传字符串或者字符,一个是传开始查找的位置,如果不传,默认从0开始，最下面是这样理解传C格式的字符串,从pos位置开始,查找s的前n个字符。

int main()
{
	string s1("lean on me ");
	string s2("on");

	cout << s1.find('a')<<endl;//结果为2
	cout << s1.find(s2, 3) << endl;//结果为5
	cout << s1.find("me ", 3) << endl;//结果为8
	cout << s1.find("me ", 5, 2) << endl;//结果为8
}

 其运行结果为：

 rfind()，其用法和find（）一致，只需要搞清楚，是从右边开始的。

c_str

对于c_str，有时候函数形参并不是string对象,而是c格式字符串,那么传入string对象则会报错,为了解决这种麻烦,便提供了该接口.

int main()
{
	string s1("abcdef");
	char* str = new char[s1.size() + 1];
	strcpy(str, s1.c_str());
	cout << str << endl;
	return  0;
}

其运行结果为： 

 substr

最后就是substr即返回对象从pos位置开始,长度为len个的子串.len如果不写,则默认是从pos位置开始,一直到末尾。

文档是这样定义：string substr (size_t pos = 0, size_t len = npos) const;

int main()
{

	string  s1("waiting for love ");
	cout << s1.substr() << endl;//获取整个字符
	cout << s1.substr(3, 4) << endl;//获取从第三个字符开始的后连续四个字符
	cout << s1.substr(5) << endl;//获取第五个字符后的所有字符


	return 0;
}

 其结果为：

以上就是本篇文章的内容了，感谢你的阅读。

如果感到有所收获的话可以给博主点一个赞哦。

如果文章内容有遗漏或者错误的地方欢迎私信博主或者在评论区指出~