STL----string模拟实现

最新推荐文章于 2024-06-12 18:28:23 发布
最新推荐文章于 2024-06-12 18:28:23 发布
阅读量89 收藏
点赞数
分类专栏： STL 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46576333/article/details/118661325
版权

string


string成员函数：
find()：查找字符 

int main() {
	string url = "https://www.baidu.com/xxx/120494/56465/";
	
	//协议
	size_t pos1 = url.find(':');
	if (pos1 != string::npos) {
		cout << url.substr(0, pos1) << endl;
	}
	
	//网址
	size_t pos2 = url.find('/', pos1 + 3);
	if (pos2 != string::npos) {
		cout << url.substr(pos1 + 3, pos2 - pos1 - 3) << endl;
	}

	//资源
	size_t pos3 = pos2;
	cout << url.substr(pos3) << endl;

	return 0;
}

简单string实现（传统写法）

如果有人要你模拟实现一个简单的string，那主要要看的就是你对深浅拷贝的理解，就是实现类的默认成员函数。

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

class String {

public:

	//构造函数 全缺省 + 一个参数
	//需要注意的是要多开一个字节的空间给 \0  并且""该字符串具有一个'\0'
	String(const char* str = "")
		:_str(new char[strlen(str) + 1])
	{
		strcpy(_str, str);
	}

	//析构函数
	~String() {
		if (_str) {
			delete[] _str;
			_str = nullptr;
		}
	}

	//拷贝构造 如果不写 编译器默认生成浅拷贝 
	//对于指针类型浅拷贝 程序会在析构时将同一块空间析构两次崩掉
	//并且因为指向同一块内存区域 会导致一个对象数据修改 影响到另一个对象的数据也被修改
	/*String(const String& s)
		:_str(new char[strlen(s._str) + 1]) {
		strcpy(_str, s._str);
	}*/

	//现代写法
	String(const String& s)
		: _str(nullptr)
	{
		String tmp(s._str);
		swap(_str, tmp._str);
	}

	//赋值运算符（两给对象都已经存在）
	//返回左值的引用 是为了连续赋值
	//如果不写 编译器会默认生成浅拷贝的赋值重载 浅拷贝必然产生和拷贝构造相同的问题
	
	//String& operator=(const String& s) {
	//	//避免自己给自己赋值
	//	if (this != &s) {
	//		//赋值时两个空间大小需要一致 但并不知道是否一致 所以直接释放掉 开一个满足的新空间进行复制
	//		delete[] _str;
	//		_str = new char[strlen(s._str) + 1];
	//		strcpy(_str, s._str);
	//	}
	//	return *this;
	//}
	
	//现代写法
	String& operator=(String s) {
		if (this != &s) {
			swap(_str, s._str);
		}
		return *this;
	}

	//返回c格式的字符数组
	const char* c_str() {
		return _str;
	}

	//重载[]运算符
	//为了可读可写 应该返回引用
	char& operator[](size_t i) {
		//使其越界直接崩掉
		assert(i < size());
		return _str[i];
	}

	size_t size() {
		return strlen(_str);
	}

private:
	char* _str;
};

关于拷贝构造和赋值函数，可以使用现代写法（一种思想）

拷贝构造现代写法

String(const String& s)
		: _str(nullptr)
	{
		String tmp(s._str);
		swap(_str, tmp._str);
	}

赋值函数的现代写法

String& operator=(String s) {
	if (this != &s) {
		swap(_str, s._str);
	}
	return *this;
}

具有增删查改接口的string实现

在简单string类中完善其他接口

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

class String {
public:

	//迭代器可以理解为类似指针的类型，有的是指针 有的不是指针
	typedef char* iterator;
	typedef const char* const_iterator;

	String(const char* str = "") {
		//strlen有消耗  这样写可以少调用
		_size = strlen(str);
		_capacity = _size;
		_str = new char[_size + 1];
		strcpy(_str, str);
	}

	~String() {
		if (_str) {
			delete[] _str;
			_str = nullptr;
			_size = _capacity = 0;
		}
	}

	void Swap(String& s) {
		swap(_str, s._str);
		swap(_size, s._size);
		swap(_capacity, s._capacity);
	}

	String(const String& s)
		: _str(nullptr),
		_size(0),
		_capacity(0)
	{
		String tmp(s._str);
		Swap(tmp);
	}

	String& operator=(String s) {
		if (this != &s) {
			Swap(s);
		}
		return *this;
	}

	char& operator[](size_t i) {
		assert(i < _size);
		return _str[i];
	}

	const char* c_str() const {
		return _str;
	}

	//返回有效字符数量
	size_t size() const {
		return _size;
	}

	//返回有效字符容量
	size_t capacity() const {
		return _capacity;
	}

	//迭代器开始位置 这里可以理解为首元素的位置
	iterator begin() {
		return _str;
	}

	const_iterator begin()const {
		return _str;
	}

	//迭代器结束位置 这里可以理解为'\0'的位置
	iterator end() {
		return _str + _size;
	}

	const_iterator end()const {
		return _str + _size;
	}

	//为字符串预留空间
	void reserve(size_t n) {
		if (n > _capacity) {
			char* tmp = new char[n + 1];
			strcpy(tmp, _str);
			delete[] _str;
			_str = tmp;
			_capacity = n;
		}
	}

	//尾插字符
	void push_back(char ch) {
		insert(_size, ch);
	}

	//追加字符串
	void append(const char* str) {
		size_t len = strlen(str);
		if (_size + len > _capacity) {
			reserve(_size + len);
		}

		strcpy(_str + _size, str);
		_size += len;
	}

	//插入字符
	void insert(size_t pos, const char ch) {
		assert(pos <= _size);

		//检查容量
		if (_size == _capacity) {
			//当前容量空的话开两个空间
			size_t newCapacity = _capacity == 0 ? 2 : _capacity * 2;
			reserve(newCapacity);
		}
		
		//要注意i最后会减为-1，无符号-1是最大值 还会判断为大于pos 
		//变成了死循环  解决办法是i使用int 然后pos也强转为int后比较
		for (int i = _size ; i >= (int)pos; --i) {
			_str[i + 1] = _str[i];
		}
		_str[pos] = ch;
		++_size;
	}

	//插入字符串
	void insert(size_t pos, const char* str) {
		assert(pos <= _size);

		size_t len = strlen(str);
		if (_size + len > _capacity) {
			reserve(_size + len);
		}

		//要注意i最后会减为-1，无符号-1是最大值 还会判断为大于pos 
		//变成了死循环  解决办法是i使用int 然后pos也强转为int后比较
		int end = _size;
		while (end >= (int)pos) {
			_str[end + len] = _str[end];
			--end;
		}

		//拷贝len个 就不会 把\0拷过来到中间
		strncpy(_str + pos, str, len);
		_size += len;
	}

	//删除
	String& erase(size_t pos = 0, size_t len = npos) {
		assert(pos < _size);

		if (len >= _size - pos) {
			_str[pos] = '\0';
			_size = pos;
		}
		else {
			for (size_t i = pos + len; i <= _size; ++i) {
				_str[i - len] = _str[i];
			}
			_size -= len;
		}
		return *this;
	}

	//指定位置开始查找第一次出现的字符
	size_t find(char c, size_t pos = 0) {
		assert(pos < _size);
		for (size_t i = pos; i < _size; ++i) {
			if (_str[i] == c) {
				return i;
			}
		}
		return npos;
	}

	//查找第一次出现的子串
	size_t find(const char* str, size_t pos = 0) {

		char* ret = strstr(_str + pos, str);
		if (ret != nullptr) {
			return npos;
		}

		//返回下标
		return ret - _str;
	}

	//字符串追加
	String& operator+=(const char* str) {
		append(str);
		return *this;
	}

	String& operator+=(char ch) {
		push_back(ch);
		return *this;
	}

	String& operator+=(const String& s) {
		append(s._str);
		return *this;
	}

	//将有效字符的个数改为n个，多出的空间用字符c填充
	void resize(size_t n, char c) {

		//需要的空间小于当前容量 就不需要开空间了
		if (n < _capacity) {
			_str[n] = '\0';
			_size = n;
		}
		else {
			//需要的空间大于当前容量，则开新空间
			if (n > _capacity) {
				reserve(n);
			}

			//从之前结尾开始填充
			for (size_t i = _size; i < n; ++i) {
				_str[i] = c;
			}
			_size = n;
			_str[_size] = '\0';
		}
	}

	//运算符重载
	bool operator>(const String& s) {
		int ret = strcmp(_str, s._str);
		return ret > 0;
	}
	bool operator==(const String& s) {
		int ret = strcmp(_str, s._str);
		return ret == 0;
	}
	bool operator<(const String& s) {
		return !(*this >= s);
	}
	bool operator>=(const String& s) {
		return *this > s || *this == s;
	}
	bool operator<=(const String& s) {
		return !(*this > s);
	}
	bool operator!=(const String& s) {
		return !(*this == s);
	}

private:
	char* _str;
	size_t _size;//已经存在的有效字符个数
	size_t _capacity;//可以容纳的有效字符个数  不包含'\0'

	static const size_t npos;//默认无符号整型的最大值
};

const size_t String::npos = -1;

//重载输出
ostream& operator<<(ostream& out, String& s) {
	for (size_t i = 0; i < s.size(); ++i) {
		out << s[i];
	}
	return out;
}

//重载输入
istream& operator>>(istream& in, String& s) {
	while (1) {
		char c;
		//使用in >> c,不会读到空格 遇到空格认为是结束
		c = in.get();

		//如不判断是否为空格 就是getline 读取一行
		//if(c=='\n'){
		if (c == ' ' || c == '\n') {
			break;
		}
		else {
			s += c;
		}
	}
	return in;
}
Hello小顾
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
STL -- String
Morn_Star_Oliver的博客
03-29 1288
预学先知 1.STL的六大组件，容器，算法，迭代器最为重要，allocator就是个内存池 2.STL是学习C++中一个很重要的方面，需要认真对待。“没有学过STL就不要说自己学过C++”； 三个境界：能用，明理，能扩展 3 .辅助学习的网站www.cplusplus.com 4.几个编码表 ascii – 表示英文编码表 unicode – 表示全世界文字编码表 utf-8 utf-16 utf-32 gbk --中文自己量身定做的编码表 Linux上一般设置utf-8 根据编码的不同，也有不同的方式进
STL库string类的模拟实现
02-28
4. string类是basic_string模板类的一个实例，它使用char来实例化basic_string模板类，并用char_traits 和allocator作为basic_string的默认参数(根于更多的模板信息请参考basic_string)。 5. 注意，这个类独立于所...
C++STL---模拟实现string
weixin_73919606的博客
05-29 877
我们这篇文章进行string的模拟实现。
STL---string类
2303_79336820的博客
01-06 972
string类的基础使用介绍
C++ STL ---- string
EQUINOX1的博客
05-19 236
STL(standard template libaray-标准模板库)：是C++标准库的重要组成部分，不仅是一个可复用的组件库，而且是一个包罗数据结构与算法的软件框架。
【C++】STL-string模拟实现
chuxinchangcun的博客
12-22 6064
public:string是一个管理字符数组的类,要求这个字符数组结尾用\0标识1.拷贝构造和赋值重载实现深拷贝2.增删查找的相关接口(跟顺序表类似)3.重载了一些常见的运算符 如: > < >> 加const2.只写接口函数 ->不加const3.可读可写接口函数 ->分为加const版本和不加const版本。
STL--string模拟实现
m0_61780496的博客
12-30 376
string类的模拟实现
C++STL---list模拟实现
weixin_73919606的博客
06-06 755
本文我们模拟实现STL中的list，为了模拟实现list，实际上我们需要实现三个类，分别为：_list_node , _list_iterator , list。
【c++】STL--string
includeevey的博客
12-02 3223
讲解非常详细，欢迎大家观看！
C++STL---string知识汇总
weixin_73919606的博客
05-26 784
我们现在开始C++STL的学习，从这时开始我们就要锻炼自己查看英文文档的能力，每种数据结构都有上百个接口函数，我们把他们全部记下来是不可能的，所以我们只记最常见的20几个接口，其他的大概熟悉有什么功能，用的时候去查看文档。
C++ STL-＞list模拟实现
FBI_BAIGOU的博客
02-16 1235
list。
STL中string类模拟实现源码
08-06
内容简介，涵盖内容广泛。源码实现参照STL源码。
string类的模拟实现
04-29
string类的模拟实现
模拟实现string类深浅拷贝
01-08
从构造，析构以及拷贝构造的方面理解string类的底层实现。 源代码获取： https://github.com/akh5/C-/blob/master/STL/Mystring.cpp string的底层通过字符指针char*通过构造函数申请对应大小的空间，并将指针指向其...
string类写时拷贝
01-07
指路：模拟实现string类。地址：https://blog.csdn.net/MPF1230/article/details/104059562 源代码获取： https://github.com/akh5/C-/blob/master/STL/copyOnWrite.cpp 由于浅拷贝多个对象共用一个资源，导致其中一...
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 982
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C++——计算不同的非空子串个数
我发布的博客，快来抄答案吧
06-09 134
BCSP-X 11题 C++代码详解
LeetCode 算法：轮转数组c++
小金牛来了
06-09 662
LeetCode 算法：轮转数组c++
手搓顺序表（C语言）
最新发布
m0_62646213的博客
06-12 1095
顺序表头插头删，尾插尾删，任意位置插入删除的实现和优劣分析
基于C++定义一个学生类，实现上课过程的模拟和平时成绩的计算，应用STL库的相关容器对数据进行存储，程序数据可以保存到文件中，开始程序时自动读取。
05-27
好的，我来帮您解答这个问题。 首先，我们需要定义一个学生类，包含学生的基本信息以及相关成绩信息： ```c++ #include <string> #include <vector> #include <iostream> using namespace std; class Student { public: string name; // 学生姓名 int age; // 学生年龄 vector<int> scores; // 存储学生各门课的成绩 // 构造函数 Student(string name, int age) : name(name), age(age) {} // 计算平均成绩 double avg_score() const { double sum = 0.0; for(int score : scores) { sum += score; } return scores.empty() ? 0.0 : sum / scores.size(); } // 输出学生信息 friend ostream& operator<<(ostream& os, const Student& student) { os << "Name: " << student.name << ", Age: " << student.age << ", Scores: "; for(int score : student.scores) { os << score << " "; } os << ", Avg Score: " << student.avg_score(); return os; } }; ``` 接下来，我们需要模拟上课过程，即随机生成学生的成绩，并将其存储到容器中： ```c++ #include <random> // 模拟上课过程，随机生成学生的成绩 void simulate_class(vector<Student>& students) { // 随机数生成器 random_device rd; mt19937 gen(rd()); uniform_int_distribution<> dis(0, 100); // 遍历学生，生成成绩 for(auto& student : students) { for(int i = 0; i < 5; i++) { student.scores.push_back(dis(gen)); } } } ``` 最后，我们需要使用STL库的相关容器对数据进行存储，并将数据保存到文件中： ```c++ #include <fstream> // 从文件中读取学生信息 void read_students(const string& filename, vector<Student>& students) { ifstream fin(filename); string name; int age, score; while(fin >> name >> age) { Student student(name, age); while(fin >> score) { student.scores.push_back(score); } students.push_back(student); } fin.close(); } // 将学生信息保存到文件中 void save_students(const string& filename, const vector<Student>& students) { ofstream fout(filename); for(const auto& student : students) { fout << student.name << " " << student.age << " "; for(int score : student.scores) { fout << score << " "; } fout << endl; } fout.close(); } int main() { vector<Student> students; // 从文件中读取学生信息 read_students("students.txt", students); // 模拟上课过程 simulate_class(students); // 将学生信息保存到文件中 save_students("students.txt", students); // 输出学生信息 for(const auto& student : students) { cout << student << endl; } return 0; } ``` 以上就是基于C++定义一个学生类，实现上课过程的模拟和平时成绩的计算，应用STL库的相关容器对数据进行存储，程序数据可以保存到文件中，开始程序时自动读取的全部代码。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值