[手撕STL] string类

最新推荐文章于 2024-05-20 19:43:04 发布
最新推荐文章于 2024-05-20 19:43:04 发布
阅读量332 收藏
点赞数 1
分类专栏： C++ 文章标签： c++ 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60565784/article/details/126350504
版权

文章目录

前言:

本文将string类中一些主要的函数模拟出来!

1.构造函数

通过缺省值构造函数,可以同时解决默认构造函数

string( const char* str="")
	:_str(new char[strlen(str)+1])
	,_size(strlen(str))
	,_capacity(strlen(str))
{
	strcpy(_str, str);
}

2. 拷贝构造和赋值重载

基本写法

这里设计深浅拷贝,如果直接调用默认拷贝构造的话就是浅拷贝,当调用析构函数的时候就会崩溃,原因就是char*指针指向同一块空间了,所以我们必须采取深拷贝的方法,重新开辟一块空间

string(const string& s)
{
	_str=new char[s._capacity+1];
	_size = s._size;
	_capacity = s._capacity;
	strcpy(_str, s._str);
}
string& operator=(const string& s)
{
	if (this != &s)
	{
		char* tmp = new char(s._capacity + 1);
		strcpy(tmp, s._str);
		delete[] _str;
		_size = s._size;
		_capacity = s._capacity;
		_str = tmp;
	}
	return *this;
}

资本思维的写法(1)

通过调用构造函数完成拷贝构造!!

void swap(string& tmp)
{
	std::swap(_str, tmp._str);
	std::swap(_size, tmp._size);
	std::swap(_capacity, tmp._capacity);

}
string(const string& s)
{
	string tmp(s._str);//调用构造函数
	swap(tmp);
}

发挥到极致的资本思维的写法(2)

之前我们都是用的引用传参,现在我们用传值传参,我知道传值传参会生成一个拷贝,所以直接让s代替tmp打工

string& operator=(string s)
{
	swap(s);
	return *this;
}
string& operator=(const string& s)
{
	if (this != &s)
	{
		string tmp(s);//调用拷贝构造
		swap(tmp);
	}
	return *this;
}

3. 析构函数

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

4. 内置函数实现(实现很常规)

	size_t size() const
	{
		return _size;
	}
	char* c_str()
	{
		return _str;
	}
	size_t capacity() const
	{
		return _capacity;
	}
	const char& operator[](size_t pos) const
	{
		assert(pos < _size);
		return _str[pos];
	}
	char& operator[](size_t pos)
	{
		assert(pos < _size);
		return _str[pos];
	}
	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)
	{
		if (_size == _capacity)
		{
			reserve(_capacity == 0 ? 4 : _capacity * 2);
		}
		_str[_size] = ch;
		++_size;
		_str[_size] = '\0';
	}
	string& operator+=(char ch)
	{
		 push_back(ch);
		 return *this;
	}
	
	void append(const string& s)
	{
		if (_size + s._size > _capacity)
		{
			reserve(_size + s._size);
		}

		strcpy(_str + _size, s._str);
		_size += s._size;
	}

	string& operator+=(const string& s)
	{
		append(s);
		return *this;
	}

	string& insert(size_t pos, char ch)
	{
		assert(pos <= _size);
		if (_size+1 == _capacity)
		{
			reserve(_capacity == 0 ? 4 : _capacity * 2);
		}
		size_t end = _size + 1;
		while (end > pos)
		{
			_str[end] = _str[end - 1];
			--end;
		}
		_str[pos] = ch;
		++_size;
		return *this;
	}
	string& insert(size_t pos, const string& s)
	{
		assert(pos <= _size);
		if (_size+s._size == _capacity)
		{
			reserve(_size + s._size);
		}
		size_t end = _size + s._size;
		while (end > pos)
		{
			_str[end] = _str[end - s._size];
			--end;
		}
		strncpy(_str + pos, s._str, s._size);
		_size+=s._size;
		return *this;
	}

	void erase(size_t pos, size_t len = npos)
	{
		assert(pos < _size);

		if (len == npos || pos + len >= _size)
		{
			_str[pos] = '\0';
			_size = pos;
		}
		else
		{
			strcpy(_str + pos, _str + pos + len);
			_size -= len;
		}
	}
	void clear()
	{
		_str[0] = '\0';
		_size = 0;
	}


	size_t find(char ch, size_t pos = 0) const
	{
		for (size_t i = pos; i < _size; ++i)
		{
			if (_str[i] == ch)
				return i;
		}
		return npos;
	}
	size_t find(const char* sub, size_t pos = 0) const
	{
		char* n = strstr(_str + pos, sub);
		if (n == nullptr)
			return npos;
		else
			return n - _str;
	}

	string substr(size_t pos, size_t len = npos) const
	{
		assert(pos < _size);
		size_t realLen = len;
		if (len == npos || pos + len > _size)//防止len过大
		{
			realLen = _size - pos;
		}

		string sub;
		for (size_t i = 0; i < realLen; ++i)
		{
			sub += _str[pos + i];
		}

		return sub;
	}
	bool operator>(const string& s) const
	{
		return strcmp(_str, s._str) > 0;
	}
	bool operator==(const string& s) const
	{

		return strcmp(_str, s._str) == 0;

	}
	bool operator>=(const string& s) const
	{
		return strcmp(_str, s._str) >= 0;

	}
	bool operator<=(const string& s) const
	{
		return strcmp(_str, s._str) <= 0;

	}
	bool operator<(const string& s) const
	{
		
		return strcmp(_str, s._str) < 0;
	}
	bool operator!=(const string& s) const
	{
		return !(*this==s);
	}

5. operator>>和operator<<

这里我并没有采用友元函数,直接通[]取到对应的字符
流插入这边做了一个小小的优化,就是我们每次输入都得+=,这用频繁的开辟空间效率较低,我们采用一个临时数组,将我们输入的这些字符都放到临时数组里然后统一+=到字符串中

ostream& operator<<(ostream& out, const string& s)
{
	for (size_t i = 0; i < s.size(); ++i)
	{
		out << s[i];
	}

	return out;
}

istream& operator>>(istream& in, string& s)
{
	s.clear();
	char ch;
	ch = in.get();
	const size_t N = 32;
	char buff[N];
	size_t i = 0;
	while (ch != ' ' && ch != '\n')
	{
		buff[i++] = ch;
		if (i == N - 1)
		{
			buff[i] = '\0';
			s += buff;
			i = 0;
		}
		ch = in.get();
	}
	buff[i] = '\0';
	s += buff;
	return in;
}

完整代码

#pragma once
#include<iostream>
#include<assert.h>
using  std::istream; 
using  std::ostream;

class string
{
public:
	typedef char* iterator;
	typedef const char* const_iterator;
	iterator begin()
	{
		return _str;
	}
	iterator end()
	{
		return _str+_size;
	}
	const_iterator begin() const
	{
		return _str;
	}
	const_iterator end() const
	{
		return _str + _size;
	}
	//string()
	//	:_str(new char[1])
	//	,_size(0)
	//	,_capacity(0)
	//{	
	//	_str[0]='\0';
	//}
	string( const char* str="")
		:_str(new char[strlen(str)+1])
		,_size(strlen(str))
		,_capacity(strlen(str))
	{
		strcpy(_str, str);
	}


	//传统写法
	//string(const string& s)
	//{
	//	_str=new char[s._capacity+1];
	//	_size = s._size;
	//	_capacity = s._capacity;
	//	strcpy(_str, s._str);
	//}

	//string& operator=(const string& s)
	//{
	//	if (this != &s)
	//	{
	//		char* tmp = new char(s._capacity + 1);
	//		strcpy(tmp, s._str);
	//		delete[] _str;
	//		_size = s._size;
	//		_capacity = s._capacity;
	//		_str = tmp;
	//	}
	//	return *this;
	//}


	 //老板思维(1)
	void swap(string& tmp)
	{
		std::swap(_str, tmp._str);
		std::swap(_size, tmp._size);
		std::swap(_capacity, tmp._capacity);

	}
	string(const string& s)
	{
		string tmp(s._str);//调用构造函数
		swap(tmp);
	}
	//string& operator=(const string& s)
	//{
	//	if (this != &s)
	//	{
	//		string tmp(s);
	//		swap(tmp);
	//	}
	//	return *this;
	//}
	//老板思维(2)
	//让s代替tmp打工
	string& operator=(string s)
	{
		swap(s);
		return *this;
	}
	~string()
	{
		_size = 0;
		_capacity = 0;
		_str = nullptr;
		delete[] _str;
	}



	size_t size() const
	{
		return _size;
	}
	char* c_str()
	{
		return _str;
	}
	size_t capacity() const
	{
		return _capacity;
	}
	const char& operator[](size_t pos) const
	{
		assert(pos < _size);
		return _str[pos];
	}
	char& operator[](size_t pos)
	{
		assert(pos < _size);
		return _str[pos];
	}
	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)
	{
		if (_size == _capacity)
		{
			reserve(_capacity == 0 ? 4 : _capacity * 2);
		}
		_str[_size] = ch;
		++_size;
		_str[_size] = '\0';
	}
	string& operator+=(char ch)
	{
		 push_back(ch);
		 return *this;
	}
	
	void append(const string& s)
	{
		if (_size + s._size > _capacity)
		{
			reserve(_size + s._size);
		}

		strcpy(_str + _size, s._str);
		_size += s._size;
	}

	string& operator+=(const string& s)
	{
		append(s);
		return *this;
	}

	string& insert(size_t pos, char ch)
	{
		assert(pos <= _size);
		if (_size+1 == _capacity)
		{
			reserve(_capacity == 0 ? 4 : _capacity * 2);
		}
		size_t end = _size + 1;
		while (end > pos)
		{
			_str[end] = _str[end - 1];
			--end;
		}
		_str[pos] = ch;
		++_size;
		return *this;
	}
	string& insert(size_t pos, const string& s)
	{
		assert(pos <= _size);
		if (_size+s._size == _capacity)
		{
			reserve(_size + s._size);
		}
		size_t end = _size + s._size;
		while (end > pos)
		{
			_str[end] = _str[end - s._size];
			--end;
		}
		strncpy(_str + pos, s._str, s._size);
		_size+=s._size;
		return *this;
	}

	void erase(size_t pos, size_t len = npos)
	{
		assert(pos < _size);

		if (len == npos || pos + len >= _size)
		{
			_str[pos] = '\0';
			_size = pos;
		}
		else
		{
			strcpy(_str + pos, _str + pos + len);
			_size -= len;
		}
	}
	void clear()
	{
		_str[0] = '\0';
		_size = 0;
	}


	size_t find(char ch, size_t pos = 0) const
	{
		for (size_t i = pos; i < _size; ++i)
		{
			if (_str[i] == ch)
				return i;
		}
		return npos;
	}
	size_t find(const char* sub, size_t pos = 0) const
	{
		char* n = strstr(_str + pos, sub);
		if (n == nullptr)
			return npos;
		else
			return n - _str;
	}

	string substr(size_t pos, size_t len = npos) const
	{
		assert(pos < _size);
		size_t realLen = len;
		if (len == npos || pos + len > _size)//防止len过大
		{
			realLen = _size - pos;
		}

		string sub;
		for (size_t i = 0; i < realLen; ++i)
		{
			sub += _str[pos + i];
		}

		return sub;
	}
	bool operator>(const string& s) const
	{
		return strcmp(_str, s._str) > 0;
	}
	bool operator==(const string& s) const
	{

		return strcmp(_str, s._str) == 0;

	}
	bool operator>=(const string& s) const
	{
		return strcmp(_str, s._str) >= 0;

	}
	bool operator<=(const string& s) const
	{
		return strcmp(_str, s._str) <= 0;

	}
	bool operator<(const string& s) const
	{
		
		return strcmp(_str, s._str) < 0;
	}
	bool operator!=(const string& s) const
	{
		return !(*this==s);
	}
private:
	char* _str;
	int _size;
	int _capacity;


	const static size_t npos = -1;
};
ostream& operator<<(ostream& out, const string& s)
{
	for (size_t i = 0; i < s.size(); ++i)
	{
		out << s[i];
	}

	return out;
}

istream& operator>>(istream& in, string& s)
{
	s.clear();
	char ch;
	ch = in.get();
	const size_t N = 32;
	char buff[N];
	size_t i = 0;
	while (ch != ' ' && ch != '\n')
	{
		buff[i++] = ch;
		if (i == N - 1)
		{
			buff[i] = '\0';
			s += buff;
			i = 0;
		}
		ch = in.get();
	}
	buff[i] = '\0';
	s += buff;
	return in;
}
相知-
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
STL 的string类怎么啦
12-31
陈皓前言上个周末在和我的同学爬香山闲聊时，同学说到STL中的string类曾经让他备受折磨，几年前他开发一个系统前对string类还比较清楚，然后随着程序的复杂度的加深，到了后期，他几乎对string类失去了信心和信任，...
STL库string类的模拟实现
02-28
4. string类是basic_string模板类的一个实例，它使用char来实例化basic_string模板类，并用char_traits 和allocator作为basic_string的默认参数(根于更多的模板信息请参考basic_string)。 5. 注意，这个类独立于所...
【C++从0到王者】第十站：手撕string
青色_忘川的博客
07-21 432
手把手教你徒手撕string
【C++】手撕string类（超实用！）
Eristic0618的博客
03-09 1338
本篇文章围绕C++中的string类展开讲解，包含string类的常见接口、模拟实现string类等内容
C++手撕string(构造+析构+拷贝+右值拷贝)
xizi_ghq的博客
12-28 501
#include<bits/stdc++.h> using namespace std; class sstring{ public: sstring(const char *p=nullptr){ cout<<"sstring(const char *p=nullptr)"<<endl; if(p==nullptr){ _p=new char[1]; _p[0]='\0'; .
【手撕】string
yanyongfu523的博客
07-19 130
模拟实现string类
【手撕STL】string类
AI_ELF的博客
12-30 591
string类标准库中的string类string类string类的常用接口说明三级目录 标准库中的string类 string类 字符串是表示字符序列的类 标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。 string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型 string类是basic_string模板类的一个实例，它使用char来实例化basic_string模板类，并用char_tra
string类的构造方法_String类重要吗_C++_STL_string_
09-30
C++ stl中重要容器string类的构造方法与基本概念和一些有用的字符串操作
STL中string类模拟实现源码
08-06
内容简介，涵盖内容广泛。源码实现参照STL源码。
【手撕String类】并测试构造、析构函数调用过程
m0_52309496的博客
03-14 151
可以看到s在出了{}范围后就无法再调用（已经出作用域了）但是并没有在作用域结束后就析构，而是在程序执行结束才析构。
手撕String类
qq_36173446的博客
01-25 355
注意：当类中包含了指针类成员时，需要重载拷贝构造函数、赋值函数和析构函数 由此面试中经常要求实现出String类的构造函数、拷贝构造函数、赋值函数以及析构函数。 其大致如下： class MyString { public: MyString(const char* str = nullptr); //普通构造函数 MyString(const MyString& other); //拷贝构造函数 ~MyString(void);
暴力学Java 手撕String
发光吖的博客
03-06 1720
String类 所属的包 java.lang包，不需要import导入。 继承关系 除默认继承java.lang.Object类外，无其它任何继承关系。 使用方式 String是一个非常特殊得引用数据类型，可以像基本数据类型一样赋值创建，也可以通过new的方式调用构造方法创建String对象。 String s1 = "abc"; String s2 = new String("abc"); 但...
C++面试题：手撕String类
weixin_44537258的博客
04-07 490
对于一个String类要自己写构造析构，避免浅拷贝等内存泄漏问题 class String{ public: String(const char* str = nullptr); //普通构造函数 String(const String& other); //拷贝构造函数 String& operator=(const String& other); //拷贝赋值函数 ~String(); //析构函数 private: char* m_dat
c++ string类的实现 手撕string类
renzemingcsdn的博客
02-11 522
要求 要求通过动态数组实现，不能分配静态定长内存。 要求实现如下函数 要求事情内存时不能使用new华为delete，new char[n_bytes] → new_char_array(int n_bytes), and delete[] p → delete_char_array(char *p)。 实现 String.cpp #include "String.h" int String::strlen(const char *s) { int len = 0; for (;
经典面试题之手撕字符串函数
Francis的博客
08-27 1162
经典面试题之手撕字符串函数最近看到一些面试C/C++的一个问题：手撕字符串函数，包括：strcpymemcpymemmovestrcatstrcmpstrstr下面一起来...
Q1：手撕String类
Water_st的博客
08-08 377
#include <iostream> #include <string> using namespace std; class MyString { public: MyString(const char* str=NULL); MyString(const MyString& string); MyString& operator=(const...
手写实现STL String类，深入理解类的底层实现原理（构造函数，拷贝构造函数，运算符重载，析构函数）
Quan的博客
03-13 322
C++ String类的实现 String类的实现是面向对象的应用，其中涉及大量的 C++ 语法，经常以面试题的形式出现，很能考察面试者的 C++ 功底。本文实现基本的 普通构造函数、拷贝构造函数、析构函数、赋值函数、输出运算符重载 下面的 类的原型、类的实现和 main函数作者均在 g++编译器下实践过，编译运行没有问题。 类的原型 string.h #ifndef _STRING #define _STRING using namespace std; class String { publ
c语言操作注意事项
最新发布
dropLin的博客
05-20 115
如果取数据的缓存变量是结构体中的成员，比如。这样操作有可能会造成内存溢出，报硬件中断。主要是用于格式化获取字符串中的数据，来设置1个字节对齐，即不能设置为。这时的结构体类型定义不能加。
STL string
08-14
STL的string是一种用来表示字符串的数据类型，相比于char*，它是一个类而不是指针。string封装了char*，提供了一系列方便的字符串操作函数，如查找、拷贝、删除、替换、插入等。与char*相比，使用string可以省去手动...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

相知-

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值