string--关于STL标准模板库

已于 2023-12-19 21:33:10 修改
阅读量349 收藏 7
点赞数 9
文章标签： c++ 开发语言
于 2023-12-19 21:31:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62038341/article/details/135094446
版权

string的概念

string是标准库的字符序列容器，使用string需要包含头文件<string>。

在使用迭代器时需要额外添加头文件：<functional>,<algorithm>。

string常用的迭代器：

string的用法示例

'string 变量可以直接通过赋值操作符 = 进行赋值'

#include <iostream>
#include <string>
using namespace std;

int main(){
    string s1;
    string s2 = "c plus plus";
    string s3 = s2;
    string s4 (5, 's');
    return 0;
}

变量 s1 只是定义但没有初始化，编译器会将默认值赋给 s1，默认值是""，也即空字符串。

变量 s2 在定义的同时被初始化为"c plus plus"。与C风格的字符串不同，string 的结尾没有结束标志'\0'。

变量 s3 在定义的时候直接用 s2 进行初始化，因此 s3 的内容也是"c plus plus"。

变量 s4 被初始化为由 5 个's'字符组成的字符串，也就是"sssss"。

获取字符串长度

string s = "studying in mayi";
int len = s.length();
cout << len << endl;

//输出：16，因为string的末尾没有“\0”字符，所有返回的是真实长度，没有+1.（空格也算长度）

转换为C风格的字符串

//打开文件时的路径，需要用到C风格的字符串，
//string 类为我们提供了一个转换函数c_str()，
//该函数能够将 string 字符串转换为C风格的字符串，并返回该字符串的 const 指针（const char*）。

string path = "D:\\demo.txt";
FILE *fp = fopen(path.c_str(), "rt");

//为了使用C语言中的 fopen() 函数打开文件，必须将 string 字符串转换为C风格的字符串。

字符串的拼接

string类对常用的运算符进行了重载，在对字符进行操作时，就会异常方便；

#include <string>
using namespace std;

int main(){
    string s1 = "first ";
    string s2 = "second ";
    char *s3 = "third ";
    char s4[] = "fourth ";
    char ch = '@';
    
    string s5 = s1 + s2;
    string s6 = s1 + s3;
    string s7 = s1 + s4;
    string s8 = s1 + ch;
    
    cout << s5 << endl 
         << s6 << endl 
         << s7 << endl 
         << s8 << endl;
    return 0;
}

输出：first second
	 first third
	 first fourth
	 first @

这里有一个通用的截取字符串并保存或者输出的方法，这里用到了序列式容器vector，之后会继续更新它的用法；

//分割字符串,通用法

void  split(const string & str,const string & sp, vector<string> &arr) {
	size_t left = 0;
	size_t pos = 0;
	while ((pos = str.find(sp, left)) != string::npos)//sp为标记字符串，left为开始下标
	{
		arr.push_back(str.substr(left, pos - left));//left为起始下标，pos-left为提取长度
		left = pos + sp.size();
	}
	if (left < str.size()) {//还未结束，要将剩余的读完
		arr.push_back(str.substr(left));
	}
}

排序函数

#include <algorithm> //需要头文件

int main4() {
	string s1 = "sdfASDMKvgp";
	string s4 = "878463129";
	sort(s4.begin(), s4.end());
	cout << s4 << endl;

	sort(s1.rbegin(), s1.rend());
	cout << s1 << endl;

	sort(s4.begin(), s4.end(), greater<char>()); //指定排序方向从大到小
	cout << s4 << endl;

	sort(s1.begin(), s1.end(), [](char a, char b) //用lambda表达式进行排序，俗称匿名函数
	{
		return a < b;
	});
	cout << s1 << endl;
	return 0;
}

手撕string类的实现

string类还是比较好实现的，底层就是用char*型指针进行频繁的动态申请内存空间并释放；

头文件：String.h 

//String.h 头文件
#include <iostream>
#include <exception>
using namespace std;
class String
{
public:
	String();//无参构造函数
	String(const char *str);//有参构造函数
	~String();//析构函数
	String(const String &other);//深拷贝构造函数

	char * c_Str() const;//转为C风格字符串
	char At(const int index) const;//下标访问函数
	char Front() const;//访问首字符函数
	char Back() const;//访问尾字符函数
	int Size() const;//获取长度
	bool Empty() const;//判空函数
	void Erase(const int index);//删除指定下标元素
	void Clear();//清空函数
	void pop_Back();//删除尾元素
	String Substr(const int index, int count) const;//截断字符串

	String operator = (const String &other);//重载=
	String &operator += (const char *str);//重载+=字符串
	String &operator += (const String &obj);//重载+=对象
	String operator + (const char *str) const;//重载+字符串
	String operator + (const String &obj) const;//重载+对象
	String operator * (const int num) const;//重载*

	bool operator != (const String &obj) const;//重载!=
	bool operator == (const String &obj) const;//重载==

	char operator [] (int index);//重载[]，可修改
	const char operator [] (const int index) const;重载[]，均不可修改

	friend istream &operator >> (istream &input, String &obj);//重载流输入>>
	friend ostream &operator << (ostream &output, const String &obj);//重载流输出<<
private:
	char *m_str;
};

源文件：String.cpp 

//String.cpp 源文件
#include "String.h"

String::String()
{
	m_str = nullptr;
}

String::String(const char *str)
{
	if (str) {
		int length = strlen(str) + 1;
		m_str = new char[length];
		strcpy_s(m_str, length, str);
        //strcpy_s拷贝函数，参数是目标字符串地址，目标字符串长度，源字符串地址
	}
	else
	{
		m_str = nullptr;
	}
}

String::~String()
{
	if (m_str) {
		delete[] m_str;
	}
}

String::String(const String & other) : String(other.m_str)
{
}

//根据需求，添加const关键字，使之成为常成员函数，防止函数内部修改对象
char * String::c_Str() const
{
	char *str = new char[strlen(m_str) + 1];
	strcpy_s(str, strlen(m_str) + 1, m_str);
	return str;
}

//根据需求，在适当的地方进行异常处理
char String::At(const int index) const
{
	if (index < 0 || index > Size()) {
		throw logic_error("下标异常！");
	}
	return m_str[index];
}

char String::Front() const
{
	if (Empty()) {
		throw logic_error("字符串为空！");
	}
	return m_str[0];
}

char String::Back() const
{
	if (Empty()) {
		throw logic_error("字符串为空！");
	}
	return m_str[strlen(m_str) - 1];
}

int String::Size() const
{
	return strlen(m_str);
}

bool String::Empty() const
{
	return m_str == nullptr;
}

void String::Erase(const int index)
{
	if (index < 0 || index > Size()) {
		throw logic_error("下标异常！");
	}
	memmove(m_str + index, m_str + index + 1, strlen(m_str) - index);
	//此函数允许有重叠的部分
	//m_str + index表示目标内存的起始地址，m_str + index + 1是源内存起始地址，strlen(m_str) - index要复制的字节数
}

void String::Clear()
{
	if (m_str) {
		delete[] m_str;
		m_str = nullptr;
	}
	else
	{
		throw logic_error("清空失败！");
	}
}

void String::pop_Back()
{
	if (m_str == nullptr) {
		return;
	}
	int length = strlen(m_str);
	m_str[length - 1] = '\0';
}

String String::Substr(const int index, int count) const
{
	String temp;
	int length = Size();
	if (index >= length) {
		return temp;
	}
	if (index + count > length) {
		count = length - index;
	}
	temp.m_str = new char[count + 1];
	strncpy_s(temp.m_str, count + 1, m_str + index, count);
	//m_str + index表示偏移后的地址，count表示要拷贝的字符数
	return temp;
}

String String::operator=(const String & other)
{
	if (m_str) {
		delete[] m_str;
	}
	m_str = nullptr;
	if (other.m_str) {
		int length = strlen(m_str) + 1;
		m_str = new char[length];
		strcpy_s(m_str, length, other.m_str);
	}
	return *this;
}

//对象和字符串都要考虑到
//思考何时需要返回引用
String & String::operator+=(const char * str)
{
	if (str == nullptr) {
		return *this;
	}
	int newlen = strlen(str) + 1;
	if (m_str) {
		newlen += strlen(m_str);
	}
	char *temp = new char[newlen];
	temp[0] = '\0';
	if (m_str) {
		strcpy_s(temp, newlen, m_str);
		delete[] m_str;
	}
	strcat_s(temp, newlen, str);
	m_str = temp;
	return *this;
}

String & String::operator+=(const String & obj)
{
	return (*this) += obj.m_str;
}

String String::operator+(const char * str) const
{
	String temp = *this;
	temp += str;
	return temp;
}

String String::operator+(const String & obj) const
{
	String temp = *this;
	temp += obj.m_str;
	return temp;
}

String String::operator*(const int num) const
{
	String temp;
	for (int i = 0; i < num; ++i) {
		temp += m_str;
	}
	return temp;
}

bool String::operator!=(const String & obj) const
{
	if (strlen(obj.m_str) != strlen(this->m_str)) {
		return true;
	}
	for (size_t i = 0; i < strlen(m_str); ++i) {
		if (this->m_str[i] != obj.m_str[i]) {
			return true;
		}
	}
	return false;
}

bool String::operator==(const String & obj) const
{
	if (strlen(obj.m_str) != strlen(this->m_str)) {
		return false;
	}
	for (size_t i = 0; i < strlen(m_str); ++i) {
		if (this->m_str[i] != obj.m_str[i]) {
			return false;
		}
	}
	return true; 
}

//根据需求，添加const关键字，使返回值、参数、对象皆不可修改。（下面俩保留一个即可）
char String::operator[](int index)
{
	if (index < 0 || index > Size()) {
		throw logic_error("下标异常！");
	}
	return m_str[index];
}

const char String::operator[](const int index) const
{
	if (index < 0 || index > Size()) {
		throw logic_error("下标异常！");
	}
	return m_str[index];
}

istream & operator >> (istream & input, String & obj)
{
	cout << "请输入字符串：";
	char buffer[1024] = { 0 };
	input >> buffer;
	if (obj.m_str) {
		delete[]obj.m_str;
		obj.m_str = nullptr;
	}
	obj.m_str = new char[strlen(buffer) + 1];
	strcpy_s(obj.m_str, strlen(buffer) + 1, buffer);
	return input;
}

ostream & operator << (ostream & output, const String & obj)
{
	if (obj.m_str) {
		output << obj.m_str;
		return output;
	}
	return output;
}

主函数：main.cpp 

//主函数接口
#include <iostream>
using namespace std;
#include "String.h"

int main() {
	//无参构造
	String str1;
	cout << "str1:" << str1 << endl;
	//有参构造
	String str2("hello");

	cout << "str2:" << str2 << endl;
	//拷贝构造函数
	String str3(str2);
	cout << "str3:" << str3 << endl;
	//c_Str()函数
	char *buffer = str2.c_Str();
	cout << "c风格字符串buffer:" << buffer << endl;
	//At()函数
	try
	{
		cout << "At()函数:" << str2.At(4) << endl;
	}
	catch (const std::exception & e)
	{
		cout << "At()函数:" << e.what() << endl;
	}
	//Front()函数
	try
	{
		cout << "Front()函数:" << str2.Front() << endl;
	}
	catch (const std::exception & e)
	{
		cout << "Front()函数:" << e.what() << endl;
	}
	//Back()函数
	try
	{
		cout << "Back()函数:" << str2.Back() << endl;
	}
	catch (const std::exception & e)
	{
		cout << "Back()函数:" << e.what() << endl;
	}
	//Size()函数
	cout << "Size()函数:" << str2.Size() << endl;
	//Empty()函数
    //默认情况下，bool类型会以1或0的形式输出,使用boolalpha()操纵器设置输出格式为true或false
	cout << "Empty()函数:" << boolalpha << str1.Empty() << endl;
	cout << "Empty()函数:" << boolalpha << str2.Empty() << endl;

	//重载=
	String str4 = str2;
	cout << "str4:" << str4 << endl;
	//重载+=，分别是 +=字符串 和 +=对象
	cout << "+= 字符串:" << (str2 += " world!") << endl;
	cout << "+= 对象:" << (str3 += str4) << endl;
	//重载[]
	cout << "下标[]:" << str2[0] << endl;
	//重载!= 和 ==
	cout << "!= 吗?:" << boolalpha << (str2 != str3) << endl;
	cout << "== 吗?:" << boolalpha << (str2 == str3) << endl;
	//重载+，分别是 +字符串 和 +对象
	cout << "+ 字符串:" << (str2 + ",c++") << endl;
	cout << "+ 对象:" << (str3 + str4) << endl;
	//重载*
	cout << "对象 * 个数:" << (str4 * 3) << endl;
	
	String str5 = "abandon_c++";
	//Substr()函数
	String temp = str5.Substr(8, 3);
	cout << "Substr()函数:" << temp << endl;
	//Erase()函数
	str5.Erase(7);
	cout << "Erase()函数:" << str5 << endl;
	//pop_Back()函数
	str5.pop_Back();
	str5.pop_Back();
	str5.pop_Back();
	cout << "pop_Back()函数:" << str5 << endl;
	//Clear()函数
	try
	{
		str1.Clear();
		cout << "Clear()函数:" << str5;
		cout << "清空成功!" << endl;
	}
	catch (const std::exception & e)
	{
		cout << "Clear()函数:" << e.what() << endl;
	}

	//重载 >> 和 << 
	cin >> str1;
	cout << "输出:" << str1 << endl;
	return 0;
}

输出：

输出：
str1:
str2:hello
str3:hello
c风格字符串buffer:hello
At()函数:o
Front()函数:h
Back()函数:o
Size()函数:5
Empty()函数:true
Empty()函数:false
str4:hello
+= 字符串:hello world!
+= 对象:hellohello
下标[]:h
!= 吗?:true
== 吗?:false
+ 字符串:hello world!,c++
+ 对象:hellohellohello
对象 * 个数:hellohellohello
Substr()函数:c++
Erase()函数:abandonc++
pop_Back()函数:abandon
Clear()函数:清空失败！
请输入字符串：这里是CSDN博客！
输出:这里是CSDN博客！

STL是C++的灵魂，这也正是C++的伟大之处，本文为基础知识分享，如有错误和补充，请在评论区指正，感谢！

望你可喜
关注
  • 9
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++ STL 标准模板库介绍与入门
dvlinker的技术专栏
05-14 2万+
C++ STL 标准模板库概述与入门
C++-STL标准模板库中的string
04-05
C++_STL标准模板库中的string
C++标准模板库STL---string类
qq_52363432的博客
03-06 1388
STL(standard template libaray-标准模板库)：是C++标准库的重要组成部分，不仅是一个可复用的组件库，而且是一个包罗数据结构与算法的软件框架。
C++STL标准模板库——String类
03-22 858
C++STL标准模板库——String类一、STL简介1.1 什么是STL？1.2 STL的六大组件二级目录三级目录 一、STL简介 1.1 什么是STL？ STL(standard template libaray-标准模板库)：是C++标准库的重要组成部分 ，不仅是一个可复用的组件库，而且是一个包罗数据结构与算法的软件框架。 1.2 STL的六大组件 二级目录 三级目录 ...
13.标准模板库(STL)
Cynan_Gattackon
04-02 2633
目录1.定义2. Vector 向量容器2.1.构造函数2.2.支持的运算符2.3. vector 函数接口的使用2.4.vector 迭代的定义补充： stl 库中的迭代器3.双向队列4.Lists（链表）5.Set 二叉树6. map 容器的使用 （重点） 1.定义 C++ STL (Standard Template Library标准模板库) 是通用类模板和算法的集合，它提供给程序员一些标准的数据结构的实现如 queues(队列), lists(链表), 和 stacks(栈)等. 2. Vecto
STL(标准模板库)
热门推荐
m0_60274660的博客
11-29 2万+
概念： STL：标准模板库，是C++标准库的重要组成部分 由概念便可以知道，STL中的所有数据结构都是以模板的方式创建的 LIST--container： list节点： list节点是一个双向指针，实质是一个模板结构体 template<class T> struct _list_node { typedef void* void_pointer; void_pointer prev;//previous void_pointer next;
c++--标准模板库(STL)
qq_42425882的博客
04-07 851
标准模板库
C++学习笔记--STL标准模板库的认识与使用--String
有朋自远方来，不亦乐乎。
11-11 477
1、什么是string？ std::string是在标准库<string>（注意不是 C 语言中的<string.h>库）中提供的一个类，本质上是std::basic_string<char>的别称。 2、为什么要用string 在 C 语言中，提供了字符串的操作，但只能通过字符数组的方式来实现字符串。而string则是一个简单的类，使用简单，在 OI 竞赛中被广泛使用。并且相较于其他 STL 容器，string的常数可以算是非常优秀的，基...
信息学奥赛中的STL(标准模板库)--2022.09.30
青少年趣味编程
09-30 3330
信息学奥赛中的STL(标准模板库)--2022.09.30
C++STL标准模板库——string类的深浅拷贝
04-01 791
一、深拷贝VS浅拷贝 面试官总喜欢让面试者实现一个string类，最主要实现的string类的构造、拷贝构造、赋值运算符重载以及析构函数。但是如果我们只实现一部分功能，其它采用编译器默认实现的功能，就涉及到了深浅拷贝问题，如下我们实现一段string代码 //string浅拷贝 namespace leon { class string { public: //string构造函数 string(const char* str = "") { assert(str); //如果str
C++标准模板库STL初步(2)
02-04
组成的库来说提供了更好的代码重用机会。在C++标准中，STL被组织为下面的几个头文件：<string>、、、、、、、、、、、、和。文件中主要介绍了前面八个的使用，并且重点介绍了他们的属性和一些成员函数的使用。
C++标准模板库STL初步(1)
02-04
组成的库来说提供了更好的代码重用机会。在C++标准中，STL被组织为下面的几个头文件：<string>、、、、、、、、、、、、和。文件中主要介绍了前面八个的使用，并且重点介绍了他们的属性和一些成员函数的使用。
STL标准模板库 字符与字符串 string，string-view，const char *
07-26
能支持任意STL容器打印
第4章C++标准库STLstring类.ppt
11-13
C++标准库STLstring类 C++标准库STLstring类是C++标准库中的一个基本组件，提供了字符串处理的基本操作。下面是该类的详细知识点： 一、string类的基本概念 * string类是一个模板类basic_string的别名，定义在...
c++实现二叉搜索树（上）
最新发布
henjdx的博客
06-12 993
二叉搜索树1.树节点增加key属性，用来比较谁大谁小，key不可以重复2.对于任意一个节点，它的key比左子树的key都大，同时也比右子树的key都小善解人意的小吉猜很多小可爱们看到这些概念都很难一下子就理解了，接下来小吉画一张图，方便大家理解（比起上面👆的概念，小吉认为下面的图比较重要）注：标的数值都是键值最后，小吉来考考你们🧐，看看你们是否是真的了解了二叉搜索树，上图👆键值6的右子树的取值范围（>6&&
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 998
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C++——计算不同的非空子串个数
我发布的博客，快来抄答案吧
06-09 143
BCSP-X 11题 C++代码详解
LeetCode 算法：轮转数组c++
小金牛来了
06-09 676
LeetCode 算法：轮转数组c++
c++|unordered系列关联式容器(unordered_set、unordered_map介绍使用+哈希结构)
weixin_68201503的博客
06-09 751
1.unordered_set与set一样元素key与value是一一对应的，且是唯一的,set中的key不能在容器中修改(元素总是const)，但是可以插入和删除,且元素是去重的。2.unordered_set与set不一样的是，其底层是由数组实现，数组存储的是，且节点值的顺序没有按照特定的顺序排序，为了能在常数范围内找到可以所对应的key，unordered_set将相同哈希值的键值对放在相同的桶中(比较抽象，待后续分析)。
std::string是标准模板库吗
07-11
是的，std::string是C++标准模板库（Standard Template Library，STL）中的一个字符串类。它提供了一种方便的方式来操作字符串，并且具有许多成员函数和操作符重载，使得字符串处理更加简单和高效。 std::string类的定义在头文件<string>中，并位于std命名空间中。它可以存储可变长度的字符序列，并且提供了许多常用的字符串操作函数，比如插入、删除、查找、子串提取等。 使用std::string类可以方便地进行字符串的操作，而不需要手动管理内存或处理字符串的长度。它是C++标准库中非常常用的类之一，使得字符串处理更加简单、安全和高效。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值