【C++】标准库:介绍string类

string

一.string类介绍

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

C++中将string封装为单独的类,string 类是 C++ 标准库中的一个非常重要的类,用于表示和操作字符串。string类位于命名空间std(标准库)下,使用string类记得加上头文件#include,并且使用命名空间using namespace std或者using std::string

cpp 复制代码
//使用时记得加上
#include<string>
using std::string;//或者using namespace std;

//源代码大致框架
namespace std
{
	class string
	{
	private:
		char* _str;
		size_t _size;
		size_t _capacity;
	};
}

二.string类的静态成员变量

静态成员变量:static const size_t npos = -1;

cpp 复制代码
int main()
{
	//static const size_t npos = -1;
	//typedef unsigned long long size_t
	//-1的原码:10000000 00000000 00000000 00000001
	//-1的反码:11111111 11111111 11111111 11111110
	//-1的补码:11111111 11111111 11111111 11111111

	//npos:-1的补码按照无符号整形打印出的值,由于静态成员变量,类外使用时加上类域
	cout << string::npos << endl;//32位环境:4294967295

	return 0;
}

三.string类的常用接口

1.构造函数(constructor)

  1. 无参构造string(); 构造空的string类对象,即空字符串。常用。
  2. 有参构造string (const char* s); 用常量字符串来构造string类对象常用。
  3. 拷贝构造string (const string& str); 用str拷贝构造string类对象常用。
  4. string (const string& str, size_t pos, size_t len = npos); 构造从下标pos开始,长度为len的子串,含缺省参数npos。
  5. string (const char* s, size_t n); 构造前n个字符组成的子串。
  6. string (size_t n, char c); 构造n个字符c组成的字符串。
cpp 复制代码
int main()
{
	string s1;
	string s2("hello xzy");
	string s3(s2);
	string s4(s2, 6, 8);
	string s5("hello xzy", 5);
	string s6(10, 'x');

	cout << s1 << endl;//输出:
	cout << s2 << endl;//输出:hello xzy
	cout << s3 << endl;//输出:hello xzy
	cout << s4 << endl;//输出:xzy
	cout << s5 << endl;//输出:hello
	cout << s6 << endl;//输出:xxxxxxxxxx

	return 0;
}

2.析构函数(destructor)

~string(); 程序结束前自动调用,释放堆区动态开辟的资源

3.运算符重载(operator)

1.operator=

  1. string& operator= (const string& str); 常用。

  2. string& operator= (const char* s);

  3. string& operator= (char c);

cpp 复制代码
int main()
{
	string s1;
	string s2;
	string s3;

	//赋值重载
	s1 = "hello xzy";
	s2 = s1;
	s3 = 'v';

	//拷贝构造
	string s4 = s1;

	cout << s1 << endl;//输出:hello xzy
	cout << s2 << endl;//输出:hello xzy
	cout << s3 << endl;//输出:v
	cout << s4 << endl;//输出:hello xzy

	return 0;
}

2.operator[]

  1. char& operator[] (size_t pos); 返回字符引用,用于下标访问,且可以修改。常用。
cpp 复制代码
int main()
{
	string s1("hello xzy");
	s1[6] = 'w';
	s1[7] = 'j';
	s1[8] = '\0';
	cout << s1 << endl;//输出:hello wj

	s1[10] = 'A';//下标越界,内部断言assert报错

	return 0;
}

3.operator+=

  1. string& operator+= (const string& str); 常用。
  2. string& operator+= (const char* s);
  3. string& operator+= (char c);
cpp 复制代码
int main()
{
	string s1("hello xzy");
	string s2(" how are you");
	s1 += s2;
	cout << s1 << endl;

	s1 += "???";
	cout << s1 << endl;

	s1 += '!';
	cout << s1 << endl;

	return 0;
}

4.operator+

  1. string operator+ (const string& lhs, const string& rhs);
  2. string operator+ (const string& lhs, const char* rhs);
  3. string operator+ (const char* lhs, const string& rhs);
cpp 复制代码
int main()
{
	string s1("hello");
	string s2 = s1 + " world";
	string s3 = "xzy " + s1;
	string s4 = s2 + s3;
	cout << s2 << endl; //hello world
	cout << s3 << endl; //xzy hello
	cout << s4 << endl; //hello worldxzy hello

	return 0;
}

4.string的四种迭代器(iterator)

迭代器是一种用于遍历容器元素的对象(并非类,而是设计模式中的一种行为模式),它提供了一种通用的访问容器元素的方式,无论容器的类型和数据结构如何。迭代器在C++标准库中被广泛使用,特别是在处理如vector、list、map等容器时。

1.正向迭代器 iterator

返回正向迭代器:可以修改字符串。

  1. iterator begin(); 返回字符串的第一个字符。
  2. iterator end(); 返回字符串最后一个有效字符(不含\0)的下一个字符。

2.反向迭代器 reverse_iterator

返回反向迭代器:可以修改字符串。

  1. reverse_iterator rbegin(); 返回字符串最后一个有效字符(不含\0)。
  2. reverse_iterator rend(); 返回字符串第一个字符的前一个字符。

3.const修饰的正向迭代器 const_iterator

返回const修饰的正向迭代器:不可以修改字符串。

  1. const_iterator begin() const;
  2. const_iterator end() const;

4.const修饰的反向迭代器 const_reverse_iterator

返回const修饰的反向迭代器:不可以修改字符串。

  1. const_reverse_iterator rbegin() const;
  2. const_reverse_iterator rend() const;

5.四种迭代器源代码

cpp 复制代码
int main()
{
	string s1("hello xzy");
	string::iterator it = s1.begin();
	while (it != s1.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;

	string s2("hello xzy");
	string::reverse_iterator rit = s2.rbegin();
	while (rit != s2.rend())
	{
		cout << *rit << " ";
		++rit;
	}
	cout << endl;

	const string s3("hello xzy");
	string::const_iterator cit = s3.begin();
	while (cit != s3.end())
	{
		//*cit += 2; s3不能修改
		cout << *cit << " ";
		++cit;
	}
	cout << endl;

	const string s4("hello xzy");
	string::const_reverse_iterator crit = s4.rbegin();
	while (crit != s4.rend())
	{
		//*crit += 2; s4不能修改
		cout << *crit << " ";
		++crit;
	}
	cout << endl;

	return 0;
}

5.string类对象的容量操作

  1. size_t size() const; 返回字符串有效字符长度(不包括\0)。常用。
  2. size_t length() const; 返回字符串有效字符长度(不包括\0)。
  3. size_t capacity() const; 返回空间总大小(不包括\0)。常用。
  4. void resize (size_t n); 为字符串预留大于等于n的空间(不包括\0),避免扩容,提高效率。常用。
  5. void clear(); 清空数据,但是一般不清容量。常用。
  6. bool empty() const; 判断是否为空。常用。
  7. void resize (size_t n); 只保留前n个数据。
  8. void resize (size_t n, char c); 保留前n个数据,若n大于容量,后面用字符c补上。

注意:

  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不会改变容量大小。

  5. 在VS2022中的容量变化:有效数据小于16时,数据存放在_buff中,无需扩容;当有效数据大于等于16时,数据存放在_str中,先2倍扩容一次,之后1.5倍扩容。

  6. 再linux中的g++编译器中的容量变化:数据只存放在_str中,容量不足就2倍扩容,感觉相当完美!

cpp 复制代码
//在VS2022下的string类
class string
{
private:
	char* _buff[16]; //有效数据小于16,存放在这里
	char* _str;      //有效数据大于等于16,存放在这里

	size_t _size;
	size_t capacity;
};
int main()
{
	string s;
	size_t sz = s.capacity();
	cout << "capacity changed: " << sz << '\n';
	cout << "making s grow:\n";
	for (int i = 0; i < 100; ++i)
	{
		s.push_back('c');
		if (sz != s.capacity())
		{
			sz = s.capacity();
			cout << "capacity changed: " << sz << '\n';
		}
	}
	cout << "VS2022下的string类的大小:" << sizeof(s) << endl;

	return 0;
}
cpp 复制代码
int main()
{
	string s1("hello xzy how are you");
	cout << s1.length() << endl;   //21
	cout << s1.size() << endl;     //21
	cout << s1.max_size() << endl; //2147483647
	cout << s1.capacity() << endl; //31

	string s2("hello xzy how are you");
	s2.reserve(100);//扩容:不一定扩100,但一定大于等于n,取决于编译器,Linux中的g++编译器扩的是100
	cout << s2.empty() << endl;    //0
	cout << s2.capacity() << endl; //111
	s2.shrink_to_fit();            //缩容
	cout << s2.capacity() << endl; //31

	string s3("hello xzy how are you");
	s3.resize(9);
	cout << s3 << endl; //hello xzy
	s3.resize(15, 'w');
	cout << s3 << endl; //hello xzywwwwww

	return 0;
}

6.string类对象的修改操作

  1. void push_back (char c); 在字符串后尾插字符c。
  2. void pop_back(); 在字符串尾删一个字符。
  3. string& append (const string& str); 在字符串后追加一个字符串。
  4. string& assign (const string& str, size_t subpos, size_t sublen); 拷贝字符串:从下标为subpos开始,拷贝长度为sublen的字符串到string类对象里面。
  5. string& insert (size_t pos, const string& str); 在pos位置处插入字符串到string类对象里面。(由于效率问题(移动数据),谨慎使用)。
  6. string& erase (size_t pos = 0, size_t len = npos); 从pos位置开始删除长度为npos个字符。(由于效率问题(移动数据),谨慎使用)。
  7. string& replace (size_t pos, size_t len, const string& str); 从pos位置开始的长度为len的子串,替换为str。(伴随着插入与删除,效率低,谨慎使用)。
  8. void swap (string& str); 交换字符串。
cpp 复制代码
int main()
{
	string s1("hello xzy");
	s1.push_back('!');
	cout << s1 << endl; //hello xzy!
	s1.pop_back();
	cout << s1 << endl; //hello xzy
	s1.append(" how are you");
	cout << s1 << endl; //hello xzy! how are you

	//可以用+=取代尾插
	s1 += "???";
	cout << s1 << endl; //hello xzy! how are you???

	string s2("hello xzy!!!");
	string s3;
	s3.assign(s2, 6, 3);
	cout << s3 << endl; //xzy

	string s4("hello xzy");
	s4.insert(0, "hello wj ");
	cout << s4 << endl; //hello wj hello xzy

	string s5("hello xzy!!!");
	s5.erase(9, 2);
	cout << s5 << endl; //hello xzy!

	string s6("hello xzy!!!");
	s6.replace(6, 5, "wj");
	cout << s6 << endl; //hello wj!

	string s7("hello x hello x");
	string tmp;
	tmp.reserve(s7.size());
	for (auto ch : s7)
	{
		if (ch == 'x')
			tmp += "wj";
		else
			tmp += ch;
	}
	cout << tmp << endl; //hello wj hello wj
	s7.swap(tmp);
	cout << s7 << endl;  //hello wj hello wj

	return 0;
}
  1. const char* c_str() const; 返回C格式字符串。方便调用C中的接口
cpp 复制代码
int main()
{
	string file;
	cin >> file;

	//c_str()函数用于调用C语言的函数,若直接传string,类型不符合(类和指针)
	FILE* fout = fopen(file.c_str(), "r");
	if (fout == NULL)
	{
		perror("open file fail!");
		exit(1);
	}
	char ch = fgetc(fout);
	while (ch != EOF)
	{
		cout << ch;
		ch = fgetc(fout);
	}
	fclose(fout);
	fout = NULL;

	return 0;
}

7.string类对象的查找操作

  1. string substr (size_t pos = 0, size_t len = npos) const; 找子串:返回从pos位置开始,长度为npos的string类。
  2. size_t find (char c, size_t pos = 0) const; 从字符串pos位置开始往后找字符c,返回该字符在字符串中的位置。
  3. size_t rfind (char c, size_t pos = npos) const; 从字符串pos位置开始往前找字符c,返回该字符在字符串中的位置。
  4. size_t find_first_of (const char* s, size_t pos = 0) const; 从字符串pos位置开始从前往后找字符串s中出现的字符,返回该字符在字符串中的位置。
  5. size_t find_last_of (const char* s, size_t pos = npos) const; 从字符串pos位置开始从后往前找字符串s中出现的字符,返回该字符在字符串中的位置。
  6. size_t find_first_not_of (const char* s, size_t pos = 0) const; 从字符串pos位置开始从前往后找字符串s中没有出现的字符,返回该字符在字符串中的位置。
  7. size_t find_last_not_of (const char* s, size_t pos = npos) const; 从字符串pos位置开始从后往前找字符串s中没有出现的字符,返回该字符在字符串中的位置。
cpp 复制代码
int main()
{
	//suffix:后缀

	string s1("test.cpp");
	size_t pos1 = s1.find(".");
	string suffix1 = s1.substr(pos1);
	cout << suffix1 << endl; //.cpp

	string s2("test.cpp.zip");
	size_t pos2 = s2.rfind(".");
	string suffix2 = s2.substr(pos2);
	cout << suffix2 << endl; //.zip

	string s3("hello xzy");
	size_t found = s3.find_first_of("xzy");
	while (found != string::npos)
	{
		s3[found] = '*';
		found = s3.find_first_of("xzy", found + 1);
	}
	cout << s3 << endl; //hello ***

	string str1("/user/bin/man");
	cout << endl << str1 << "的路径名与文件名如下:" << endl;
	size_t found1 = str1.find_last_of("/\\");
	cout << "path:" << str1.substr(0, found1) << endl;
	cout << "file:" << str1.substr(found1 + 1) << endl;

	string str2("c:\\windows\\winhelp.exe");
	cout << endl << str2 << "的路径名与文件名如下:" << endl;
	size_t found2 = str2.find_last_of("/\\");
	cout << "path:" << str2.substr(0, found2) << endl;
	cout << "file:" << str2.substr(found2 + 1) << endl;

	return 0;
}

8.string类对象的遍历操作

1.下标 + []

cpp 复制代码
int main()
{
	string s1("hello xzy");
	//1.下标+[]
	for (int i = 0; i < s1.size(); i++)
	{
		s1[i] += 2;//可以修改
		cout << s1[i] << " ";
	}
	cout << endl << s1 << endl;
	return 0;
}

2.迭代器

cpp 复制代码
int main()
{
	string s1("hello xzy");
	//2.迭代器
	string::iterator it = s1.begin();
	while (it != s1.end())
	{
		*it += 2;//可以修改
		cout << *it << " ";
		++it;
	}
	cout << endl << s1 << endl;
	return 0;
}

3.auto和范围for

cpp 复制代码
int main()
{
	string s1("hello xzy");
	//3.范围for:字符赋值,自动迭代,自动判断结束
	//  底层就是迭代器
	for (auto ch : s1)
	{
		ch += 2;//修改ch对于s1无影响,ch是它的拷贝
		cout << ch << ' ';
	}
	cout << endl << s1 << endl;
	return 0;
}
cpp 复制代码
int main()
{
	string s1("hello xzy");
	for (auto& ch : s1)//引用:取别名,就可以修改s1
	{
		ch += 2;
		cout << ch << ' ';
	}
	cout << endl << s1 << endl;
	return 0;
}
1.auto关键字
  1. 在早期C/C++中auto的含义是:使用auto修饰的变量,是具有自动存储器的局部变量,后来这个不重要了。C++11中,标准委员会变废为宝赋予了auto全新的含义即:auto不再是一个存储类型指示符,而是作为一个新的类型指示符来指示编译器auto声明的变量必须由编译器在编译时期 推导而得

  2. 用auto声明指针类型时,用auto和auto*没有任何区别,但用auto声明引用类型时则必须加&。

  3. 当在同一行声明多个变量时,这些变量必须是相同的类型,否则编译器将会报错,因为编译器实际只对第一个类型进行推导,然后用推导出来的类型定义其他变量。

  4. auto不能作为函数的参数,可以做返回值,但是建议谨慎使用。

  5. auto不能直接用来声明数组。

cpp 复制代码
#include<map>
//auto不能做参数
//void func1(auto a) error
//{}

//auto可以做返回值,但是建议谨慎使用
auto func2()
{
	return 2;
}

int main()
{
	int a = 10;
	auto b = a;//编译期间自动推导类型
	auto c = 'a';
	auto d = func2();
	//auto e; auto必须初始化,否则不知道开多少空间

	int x = 10;
	auto y = &x;
	auto* z = &x;//可以不写*
	auto& m = x;//必须加上&

	auto aa = 1, bb = 2;//right
	//auto cc = 3, dd = 4.0; error必须始终推导为同一类型
	//auto array[] = { 4, 5, 6 }; error数组不能具有其中包含"auto"的元素类型

	// auto 的价值
	map<string, string> dict; //初始化二叉树
	//map<string, string>::iterator mit = dict.begin();
	auto mit = dict.begin();

	cout << typeid(mit).name() << endl;

	return 0;
}
2.范围for
  1. 对于一个有范围的集合而言,由程序员来说明循环的范围是多余的,有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。for循环后的括号由冒号" :"分为两部分:第一部分是范围内用于迭代的变量,第二部分则表示被迭代的范围,自动迭代,自动取数据,自动判断结束。

  2. 范围for可以作用到数组和容器对象上进行遍历。

  3. 范围for的底层很简单,容器遍历实际就是替换为迭代器,这个从汇编层也可以看到。

cpp 复制代码
int main()
{
	int array[] = { 1, 2, 3, 4, 5 };

	//范围for适用于《容器》和《数组》
	// C++98的遍历
	for (int i = 0; i < sizeof(array) / sizeof(array[0]); i++)
	{
		cout << array[i] << ' ';
	}
	cout << endl;

	// C++11的遍历
	for (auto& i : array)
	{
		cout << i << ' ';
	}
	cout << endl;

	return 0;
}

四.非成员函数:getline()

  1. istream& getline (istream& is, string& str, char delim); delim:分隔符
  2. istream& getline (istream& is, string& str);

类似C语言中的scanf("%s", str),但是其遇到空格会停止;

C++中引入了getline优化了scanf遇到的问题,默认遇到\n才停止,也可以自定义停止字符delim。

例题:字符串最后一个单词的长度

cpp 复制代码
#include <iostream>
#include<string>
using namespace std;

int main() 
{
    string str;
    getline(cin, str);
    size_t pos = str.rfind(' ');
    string sub = str.substr(pos + 1);
    cout << sub.size() << endl;
}
相关推荐
不去幼儿园2 分钟前
【MARL】深入理解多智能体近端策略优化(MAPPO)算法与调参
人工智能·python·算法·机器学习·强化学习
Mr_Xuhhh4 分钟前
重生之我在学环境变量
linux·运维·服务器·前端·chrome·算法
Ajiang28247353041 小时前
对于C++中stack和queue的认识以及priority_queue的模拟实现
开发语言·c++
盼海1 小时前
排序算法(五)--归并排序
数据结构·算法·排序算法
幽兰的天空1 小时前
Python 中的模式匹配:深入了解 match 语句
开发语言·python
Theodore_10224 小时前
4 设计模式原则之接口隔离原则
java·开发语言·设计模式·java-ee·接口隔离原则·javaee
网易独家音乐人Mike Zhou4 小时前
【卡尔曼滤波】数据预测Prediction观测器的理论推导及应用 C语言、Python实现(Kalman Filter)
c语言·python·单片机·物联网·算法·嵌入式·iot
‘’林花谢了春红‘’6 小时前
C++ list (链表)容器
c++·链表·list
----云烟----6 小时前
QT中QString类的各种使用
开发语言·qt
lsx2024066 小时前
SQL SELECT 语句:基础与进阶应用
开发语言